ESP32 Projet

Simulation du fonctionnement des barrières des chemins de fer avec ESP32

27-12-21 2767

Une barrière de chemin de fer est un dispositif de sécurité utilisé pour bloquer l’accès à une voie ferrée afin de protéger les personnes et les véhicules des trains en circulation. Les barrières de chemin de fer sont généralement placées à l’entrée des passages à niveau et sont actionnées par un système de détection de mouvement qui active les barrières lorsqu’un train approche.

Les barrières de chemin de fer sont généralement constituées d’un bras métallique qui s’abaisse pour bloquer l’accès à la voie ferrée. Elles peuvent être manuelles, c’est-à-dire actionnées par un opérateur, ou automatiques, c’est-à-dire actionnées par un système de détection de mouvement. Les barrières de chemin de fer sont souvent accompagnées de panneaux d’avertissement et de feux clignotants pour alertes les personnes de l’arrivée d’un train.

Les barrières de chemin de fer sont un élément important de la sécurité ferroviaire et sont utilisées dans de nombreux pays à travers le monde pour protéger les personnes et les véhicules des trains en circulation.

But de ce projet:

Dans ce projet, nous allons réaliser un système qui simulent le fonctionnement des barrières automatiques pour les chemins de fer des trains.

On concevoir une barrière de chemin de fer commandée par une carte ESP32, qui est une carte de développement électronique dotée d’un processeur Arm Cortex M4, d’un module Wi-Fi et d’un module Bluetooth.

Pour concevoir une barrière de chemin de fer commandée par la carte ESP32, on va utiliser le servomoteur continu pour actionner le mécanisme de levage et de baisse de la barrière. on va également utiliser un capteurs à ultrasons HC-SR04 pour détecter l’approche du train et déclencher l’ouverture ou la fermeture de la barrière.

Fonctionnement de la barrière contrôlée par ESP32:

Composants nécessaires

Carte ESP32

ESP32 est une carte de développement électronique basée sur le microcontrôleur ESP32 de la société Espressif. Il s’agit d’un microcontrôleur à double cœur avec un processeur principal Xtensa LX6 et un processeur secondaire dedié au traitement du signal. La carte ESP32 est conçue pour être utilisée dans les applications IoT (Internet des objets) et comprend une variété de fonctionnalités pour faciliter la communication avec d’autres dispositifs et l’accès à Internet.

Voici quelques-unes des principales caractéristiques de la carte ESP32 :

Bluetooth et WiFi : La carte ESP32 inclut un module WiFi et Bluetooth pour faciliter la communication sans fil avec d’autres dispositifs.
Connectivité : La carte ESP32 est équipée de plusieurs ports de communication, tels que USB, UART, I2C et SPI, ce qui la rend idéale pour la communication avec d’autres composants électroniques.
Mémoire : La carte ESP32 dispose de 512 Ko de mémoire flash et de 8 Mo de RAM.
Energie : La carte ESP32 est alimentée par une tension de 3,3 V et est dotée d’un circuit de gestion de l’alimentation pour gérer les périodes de veille et d’arrêt.
Logiciels : La carte ESP32 est compatible avec un large éventail de logiciels de développement, tels que Arduino, ESP-IDF et MicroPython. Cela permet aux développeurs de choisir le logiciel de développement qui leur convient le mieux.

2 Capteurs HC-SR04

Le capteur HC-SR04 est un capteur de distance à ultrasons qui peut être utilisé pour mesurer la distance entre l’objet et le capteur en envoyant une impulsion ultrasonore et en mesurant le temps qu’il faut pour qu’elle soit renvoyée. Le capteur HC-SR04 comprend deux éléments transducteurs ultrasonores, un émetteur et un récepteur. L’émetteur envoie une impulsion ultrasonore qui est renvoyée par l’objet lorsqu’elle heurte sa surface. Le récepteur reçoit l’impulsion renvoyée et le temps qui s’écoule entre l’envoi de l’impulsion et sa réception est mesuré. La distance de l’objet peut alors être déterminée en utilisant la vitesse de l’onde ultrasonore et le temps mesuré.

Le capteur HC-SR04 est largement utilisé dans les projets de robotique et de domotique car il est peu coûteux, facile à utiliser et fiable. Il peut être facilement connecté à un microcontrôleur ou à un ordinateur pour permettre la mesure de la distance et la prise de décision en conséquence.

2 servomoteurs

Un servomoteur est un moteur électrique qui peut être utilisé pour commander la position, la vitesse ou la force d’un système mécanique. Les servomoteurs sont souvent utilisés dans les applications de contrôle de mouvement précis, telles que les robots, les systèmes de positionnement et les machines-outils.

Un servomoteur comprend un moteur électrique, un réducteur et un dispositif de commande. Le moteur électrique est utilisé pour fournir la force de déplacement. Le réducteur est utilisé pour réduire la vitesse et augmenter la force du moteur. Le dispositif de commande est utilisé pour contrôler la position, la vitesse ou la force du servomoteur.

Il existe plusieurs types de servomoteurs, qui diffèrent principalement par leur méthode de commande et par leur capacité de déplacement. Les servomoteurs peuvent être commandés par impulsion, par tension ou par courant. Ils peuvent également être classés selon leur capacité de déplacement en servomoteurs linéaires et en servomoteurs rotatifs.

module d’alimentation 3.3V/5V

Un module d’alimentation 3.3V/5V est un dispositif électronique utilisé pour fournir une tension de 3,3 volts ou de 5 volts à un circuit électrique. Ces modules sont souvent utilisés pour alimenter des cartes de développement électronique, des capteurs et d’autres dispositifs électroniques qui nécessitent une tension de fonctionnement stable et précise.

des LEDs

Une LED (Light Emitting Diode, ou diode électroluminescente) est un dispositif électronique qui émet de la lumière lorsqu’un courant électrique le traverse. Les LEDs sont souvent utilisées comme sources de lumière dans les équipements électroniques, les panneaux d’affichage et les éclairages, en raison de leur faible consommation d’énergie et de leur durée de vie relativement longue.

plaque d’essai

Une plaque d’essai est un type de carte de développement électronique qui permet aux développeurs de tester et de prototyper facilement des circuits électroniques. Elles sont souvent utilisées par les développeurs pour tester rapidement des idées et des conceptions avant de les intégrer à un projet plus important ou de les intégrer dans une carte de développement plus permanente.

Les plaques d’essai sont généralement basées sur un microcontrôleur, qui est un processeur facile à utiliser et à programmer qui peut être utilisé pour contrôler une variété de circuits électroniques. Les plaques d’essai incluent généralement des broches d’extension qui permettent de connecter facilement des composants électroniques tels que des capteurs, des afficheurs, des moteurs et d’autres composants.

fils de connexion

Les fils de connexion sont des fils électriques utilisés pour connecter des composants électroniques à une carte de développement ESP32. Ils sont généralement utilisés pour connecter des capteurs, des actionneurs, des afficheurs et d’autres composants à la carte ESP32 afin de créer des circuits électroniques.

Il existe deux types de fils de connexion: les fils de connexion mâle-mâle et les fils de connexion mâle-femelle. Les fils de connexion mâle-mâle sont utilisés pour connecter des composants qui ont tous deux des broches mâles, tandis que les fils de connexion mâle-femelle sont utilisés pour connecter des composants avec une broche mâle et une broche femelle.

Les fils de connexion sont généralement fabriqués en cuivre ou en alliage de cuivre et sont revêtus d’un isolant en plastique pour protéger les fils électriques et empêcher les courts-circuits. Ils sont disponibles dans une variété de couleurs pour aider à identifier et organiser les différents fils dans un circuit.

train jouet

Montage:

Pour faire le montage, on a connecté:

Pour le premier capteur sonore HC-SR04 :

la broche VCC à la broche 3.3V de ESP32
la broche Trig à la broche D5 de ESP32
la broche ECHO à la broche D18 de ESP32
la broche GND à la broche GND de ESP32

Pour le deuxième capteur sonore HC-SR04 :

la broche VCC à la broche 3.3V de ESP32
la broche Trig à la broche D22 de ESP32
la broche ECHO à la broche D23 de ESP32
la broche GND à la broche GND de ESP32

Pour le premier servomoteur:

fil rouge : fil de l’alimentation à relier à la borne 5V du module de l’alimentation
fil marron : fil à relier à la broche GND de ESP32
Jaune : fil de signal de positionnement branché à la broche D4 de ESP32

Pour le deuxième servomoteur:

fil rouge : fil de l’alimentation à relier à la borne 5V du module de l’alimentation
fil marron : fil à relier à la broche GND de ESP32
Jaune : fil de signal de positionnement branché à la broche D21 de ESP32

Pour les LEDs:

les bornes (-) des LEDs à GND de ESP32
la borne(+) du premier LED rouge à la broche D2 de ESP32
la borne(+) du deuxième LED rouge à la broche D19 de ESP32

Programmes micropython

Voici les programmes micropython qui permettent de :

calculer la distance entre le capteur HC-SR04 et l’objet détecté
faire élever ou baisser les barrières
allumer ou éteindre des LEDs

esp32-barrieres.py:

import machine
from hcsr04 import HCSR04
from machine import Pin
from servo import Servo
import utime

sensor1 = HCSR04(trigger_pin=5,echo_pin=18,echo_timeout_us=1000000)
sensor2 = HCSR04(trigger_pin=22,echo_pin=23,echo_timeout_us=1000000)
servo1_pin = machine.Pin(4)
servo2_pin = machine.Pin(21)
my_servo1 = Servo(servo1_pin)
my_servo2 = Servo(servo2_pin)
led1=Pin(2,Pin.OUT)
led2=Pin(19,Pin.OUT)
i1=90
i2=90
while True:
 distance1 = sensor1.distance_cm()
 distance2 = sensor2.distance_cm() 
 if distance1<4 and distance1>0: # si le capteur hc-sr04 detecte l'arrivee du train
  while i1 > 0: 
      led1.value(1) # allumer la LED rouge
      my_servo1.write_angle(i1) # baisser la barriere
      utime.sleep_ms(10)
      i1-=1
 else: # en abscence du train
  while i1 < 90:
      led1.value(0) # eteindre la led rouge
      my_servo1.write_angle(i1) # elever la barriere
      utime.sleep_ms(10)
      i1+=1
  if distance2<4 and distance2>0: # si le capteur hc-sr04 detecte l'arrivee du train
   while i2 > 0:
       led2.value(1) # allumer la LED rouge
       my_servo2.write_angle(i2)# baisser la barriere
       utime.sleep_ms(10)
       i2-=1
  else: # en abscence du train
   while i2 < 90:
       led2.value(0)# eteindre la led rouge
       my_servo2.write_angle(i2) # elever la barriere
       utime.sleep_ms(10)
       i2+=1

import machine

from hcsr04 import HCSR04

from machine import Pin

from servo import Servo

import utime

sensor1 = HCSR04(trigger_pin=5,echo_pin=18,echo_timeout_us=1000000)

sensor2 = HCSR04(trigger_pin=22,echo_pin=23,echo_timeout_us=1000000)

servo1_pin = machine.Pin(4)

servo2_pin = machine.Pin(21)

my_servo1 = Servo(servo1_pin)

my_servo2 = Servo(servo2_pin)

led1=Pin(2,Pin.OUT)

led2=Pin(19,Pin.OUT)

i1=90

i2=90

while True:

distance1 = sensor1.distance_cm()

distance2 = sensor2.distance_cm()

if distance1<4 and distance1>0: # si le capteur hc-sr04 detecte l'arrivee du train

while i1 > 0:

led1.value(1) # allumer la LED rouge

my_servo1.write_angle(i1) # baisser la barriere

utime.sleep_ms(10)

i1-=1

else: # en abscence du train

while i1 < 90:

led1.value(0) # eteindre la led rouge

my_servo1.write_angle(i1) # elever la barriere

utime.sleep_ms(10)

i1+=1

if distance2<4 and distance2>0: # si le capteur hc-sr04 detecte l'arrivee du train

while i2 > 0:

led2.value(1) # allumer la LED rouge

my_servo2.write_angle(i2)# baisser la barriere

utime.sleep_ms(10)

i2-=1

else: # en abscence du train

while i2 < 90:

led2.value(0)# eteindre la led rouge

my_servo2.write_angle(i2) # elever la barriere

utime.sleep_ms(10)

i2+=1

servo.py

from machine import PWM
import math

# originally by Radomir Dopieralski http://sheep.art.pl
# from https://bitbucket.org/thesheep/micropython-servo

class Servo:
    """
    A simple class for controlling hobby servos.
    Args:
        pin (machine.Pin): The pin where servo is connected. Must support PWM.
        freq (int): The frequency of the signal, in hertz.
        min_us (int): The minimum signal length supported by the servo.
        max_us (int): The maximum signal length supported by the servo.
        angle (int): The angle between the minimum and maximum positions.
    """
    def __init__(self, pin, freq=50, min_us=600, max_us=2400, angle=180):
        self.min_us = min_us
        self.max_us = max_us
        self.us = 0
        self.freq = freq
        self.angle = angle
        self.pwm = PWM(pin, freq=freq, duty=0)

    def write_us(self, us):
        """Set the signal to be ``us`` microseconds long. Zero disables it."""
        if us == 0:
            self.pwm.duty(0)
            return
        us = min(self.max_us, max(self.min_us, us))
        duty = us * 1024 * self.freq // 1000000
        self.pwm.duty(duty)

    def write_angle(self, degrees=None, radians=None):
        """Move to the specified angle in ``degrees`` or ``radians``."""
        if degrees is None:
            degrees = math.degrees(radians)
        degrees = degrees % 360
        total_range = self.max_us - self.min_us
        us = self.min_us + total_range * degrees // self.angle
        self.write_us(us)

from machine import PWM

import math

# originally by Radomir Dopieralski http://sheep.art.pl

# from https://bitbucket.org/thesheep/micropython-servo

class Servo:

"""

A simple class for controlling hobby servos.

Args:

pin (machine.Pin): The pin where servo is connected. Must support PWM.

freq (int): The frequency of the signal, in hertz.

min_us (int): The minimum signal length supported by the servo.

max_us (int): The maximum signal length supported by the servo.

angle (int): The angle between the minimum and maximum positions.

"""

def __init__(self, pin, freq=50, min_us=600, max_us=2400, angle=180):

self.min_us = min_us

self.max_us = max_us

self.us = 0

self.freq = freq

self.angle = angle

self.pwm = PWM(pin, freq=freq, duty=0)

def write_us(self, us):

"""Set the signal to be ``us`` microseconds long. Zero disables it."""

if us == 0:

self.pwm.duty(0)

return

us = min(self.max_us, max(self.min_us, us))

duty = us * 1024 * self.freq // 1000000

self.pwm.duty(duty)

def write_angle(self, degrees=None, radians=None):

"""Move to the specified angle in ``degrees`` or ``radians``."""

if degrees is None:

degrees = math.degrees(radians)

degrees = degrees % 360

total_range = self.max_us - self.min_us

us = self.min_us + total_range * degrees // self.angle

self.write_us(us)

hc-sr04.py:

import machine, time
from machine import Pin

__version__ = '0.2.0'
__author__ = 'Roberto S鐠嬶箯chez'
__license__ = "Apache License 2.0. https://www.apache.org/licenses/LICENSE-2.0"

class HCSR04:
    """
    Driver to use the untrasonic sensor HC-SR04.
    The sensor range is between 2cm and 4m.

    The timeouts received listening to echo pin are converted to OSError('Out of range')

    """
    # echo_timeout_us is based in chip range limit (400cm)
    def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):
        """
        trigger_pin: Output pin to send pulses
        echo_pin: Readonly pin to measure the distance. The pin should be protected with 1k resistor
        echo_timeout_us: Timeout in microseconds to listen to echo pin. 
        By default is based in sensor limit range (4m)
        """
        self.echo_timeout_us = echo_timeout_us
        # Init trigger pin (out)
        self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)
        self.trigger.value(0)

        # Init echo pin (in)
        self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

    def _send_pulse_and_wait(self):
        """
        Send the pulse to trigger and listen on echo pin.
        We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received.
        """
        self.trigger.value(0) # Stabilize the sensor
        time.sleep_us(5)
        self.trigger.value(1)
        # Send a 10us pulse.
        time.sleep_us(10)
        self.trigger.value(0)
        try:
            pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)
            return pulse_time
        except OSError as ex:
            if ex.args[0] == 110: # 110 = ETIMEDOUT
                raise OSError('Out of range')
            raise ex

    def distance_mm(self):
        """
        Get the distance in milimeters without floating point operations.
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.34320 mm/us that is 1mm each 2.91us
        # pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582 
        mm = pulse_time * 100 // 582
        return mm

    def distance_cm(self):
        """
        Get the distance in centimeters with floating point operations.
        It returns a float
        """
        pulse_time = self._send_pulse_and_wait()

        # To calculate the distance we get the pulse_time and divide it by 2 
        # (the pulse walk the distance twice) and by 29.1 becasue
        # the sound speed on air (343.2 m/s), that It's equivalent to
        # 0.034320 cm/us that is 1cm each 29.1us
        cms = (pulse_time / 2) / 29.1
        return cms

import machine, time

from machine import Pin

__version__ = '0.2.0'

__author__ = 'Roberto S鐠嬶箯chez'

__license__ = "Apache License 2.0. https://www.apache.org/licenses/LICENSE-2.0"

class HCSR04:

"""

Driver to use the untrasonic sensor HC-SR04.

The sensor range is between 2cm and 4m.

The timeouts received listening to echo pin are converted to OSError('Out of range')

"""

# echo_timeout_us is based in chip range limit (400cm)

def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):

"""

trigger_pin: Output pin to send pulses

echo_pin: Readonly pin to measure the distance. The pin should be protected with 1k resistor

echo_timeout_us: Timeout in microseconds to listen to echo pin.

By default is based in sensor limit range (4m)

"""

self.echo_timeout_us = echo_timeout_us

# Init trigger pin (out)

self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)

self.trigger.value(0)

# Init echo pin (in)

self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

def _send_pulse_and_wait(self):

"""

Send the pulse to trigger and listen on echo pin.

We use the method `machine.time_pulse_us()` to get the microseconds until the echo is received.

"""

self.trigger.value(0) # Stabilize the sensor

time.sleep_us(5)

self.trigger.value(1)

# Send a 10us pulse.

time.sleep_us(10)

self.trigger.value(0)

try:

pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)

return pulse_time

except OSError as ex:

if ex.args[0] == 110: # 110 = ETIMEDOUT

raise OSError('Out of range')

raise ex

def distance_mm(self):

"""

Get the distance in milimeters without floating point operations.

"""

pulse_time = self._send_pulse_and_wait()

# To calculate the distance we get the pulse_time and divide it by 2

# (the pulse walk the distance twice) and by 29.1 becasue

# the sound speed on air (343.2 m/s), that It's equivalent to

# 0.34320 mm/us that is 1mm each 2.91us

# pulse_time // 2 // 2.91 -> pulse_time // 5.82 -> pulse_time * 100 // 582

mm = pulse_time * 100 // 582

return mm

def distance_cm(self):

"""

Get the distance in centimeters with floating point operations.

It returns a float

"""

pulse_time = self._send_pulse_and_wait()

# To calculate the distance we get the pulse_time and divide it by 2

# (the pulse walk the distance twice) and by 29.1 becasue

# the sound speed on air (343.2 m/s), that It's equivalent to

# 0.034320 cm/us that is 1cm each 29.1us

cms = (pulse_time / 2) / 29.1

return cms

Vous pouvez voir aussi

Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

22-02-23

Simulation du fonctionnement des barrières des chemins de fer avec ESP32

But de ce projet:

Fonctionnement de la barrière contrôlée par ESP32:

Composants nécessaires

Montage:

Programmes micropython

Vous pouvez voir aussi

Afficher les données de localisation envoyées par le GPS NEO-M6 en utilisant la carte ESP32

Construction d’un robot commandé par Arduino qui détecte et évite les obstacles

0 commentaire

Laisser un commentaire

Annuler la réponse

Tutoriels récents

Capteur ultrason Arduino

Réalisation d’un robot suiveur de ligne avec Micro:bit

Utilisation de la caméra OV7670 avec la carte Arduino UNO

Serveur Web de diffusion vidéo avec ESP32-CAM

Tutos les plus vus

Système d’arrosage automatique avec Arduino

Allumer une LED par Arduino

Réalisation d’une barrière de parking automatique avec Arduino

Utilisation du capteur Ultrason HC-SR04 avec l’Arduino

Tutos les plus commentés

Commander un moteur par Arduino et le module L298N

Système de mesure du niveau d’eau contrôlé par Arduino

Système d’arrosage automatique avec Arduino

Commander un moteur à courant continu avec Micro:bit