ESP32 Projet voiture

Construction d’un robot commandé par la carte ESP32 qui détecte et évite les obstacles

07-02-23 1803

Un véhicule robot est un véhicule automatisé qui utilise des algorithmes de contrôle et de navigation pour se déplacer sans intervention humaine. Les véhicules robots peuvent être utilisés pour des applications telles que la livraison de colis, la reconnaissance et l’inspection, le transport de personnes et la cartographie automatisée. Les véhicules robots peuvent utiliser des technologies telles que la vision par ordinateur, les capteurs GPS et LIDAR pour naviguer de manière autonome.

Les robots qui détectent les obstacles utilisent des capteurs pour percevoir leur environnement et éviter les obstacles en temps réel. Les capteurs couramment utilisés pour détecter les obstacles comprennent le LIDAR, la caméra, le radar et les capteurs ultrasons. Les informations collectées par ces capteurs sont utilisées pour alimenter un algorithme de contrôle du mouvement du robot, qui peut ajuster sa trajectoire en temps réel pour éviter les obstacles. Les robots peuvent également utiliser des techniques de cartographie en temps réel pour construire une carte de leur environnement et planifier une trajectoire sécuritaire pour atteindre leur destination.

Présentation du robot commandé par la carte ESP32 qui détecte et évite les obstacles:

Un robot commandé par une carte ESP32 qui détecte et évite les obstacles est un robot autonome qui utilise une carte de contrôle ESP32 pour percevoir son environnement et éviter les obstacles en temps réel. La carte ESP32 peut être programmée pour collecter des informations à partir du capteur HC-SR04 et utiliser ces informations pour alimenter un algorithme de contrôle du mouvement du robot. L’algorithme peut ajuster la trajectoire du robot en temps réel pour éviter les obstacles rencontrés. Cette fonctionnalité permet au robot de se déplacer de manière autonome et de réaliser des tâches sans intervention humaine.

Fonctionnement du robot:

Voici un organigramme général du fonctionnement d’un robot capable de détecter et d’éviter les obstacles commandé par la carte Micro:bit :

Initialisation : le robot est allumé et les différents composants sont initialisés, notamment les capteurs, les moteurs, et la carte Micro:bit.
Collecte de données : le capteurs HC-SR04 collecte des informations sur l’environnement du robot, telles que la distance à des obstacles.
Analyse des données : la carte ESP32 analyse les données collectées par les capteurs pour déterminer la présence et la distance d’un obstacle.
Prise de décision : en fonction des informations collectées et analysées, la carte ESP32 décide de la meilleure façon d’éviter l’obstacle.
Contrôle des moteurs : la carte ESP32 envoie des commandes aux moteurs pour effectuer les mouvements nécessaires pour éviter l’obstacle.
Boucle de contrôle : ce processus est répété en permanence pour permettre au robot de détecter et d’éviter continuellement les obstacles sur son chemin.

Les composants nécessaires

La carte ESP32

La carte ESP32 est une carte de contrôle de microcontrôleur de bout en bout conçue pour les applications IoT (Internet des objets). Elle est équipée d’un processeur dual-core à 160 MHz et d’un grand nombre de capteurs intégrés, tels que le Wi-Fi, le Bluetooth, les capteurs de mouvement et de pression. Cette carte offre également une grande quantité de mémoire RAM et de mémoire flash pour stocker des programmes et des données. La carte ESP32 est largement utilisée dans les applications de robotique, d’automatisation et d’objets connectés en raison de sa puissance de traitement, de sa connectivité Wi-Fi et Bluetooth et de sa faible consommation d’énergie.

Module L298N

Le module L298N est un module de contrôle de moteur pour robots à deux roues. Il permet de contrôler la vitesse et la direction de deux moteurs à courant continu (DC) indépendamment les uns des autres. Il comporte une interface pour connecter des microcontrôleurs tels que l’Arduino pour contrôler les moteurs en fonction de l’entrée du programme. Le module L298N utilise une technique de modélisation de pont en H pour contrôler les moteurs, ce qui permet de changer de direction de rotation en inversant simplement la polarité de l’alimentation du moteur. En utilisant le module L298N, il est possible de construire un robot à deux roues autonome qui peut se déplacer dans une direction donnée, tourner et éviter les obstacles.

Le module L298N et la carte ESP32 peuvent être utilisés ensemble pour construire un robot autonome à deux roues. La carte ESP32 peut être utilisée pour concevoir et exécuter le programme de contrôle du robot, qui peut collecter des données à partir de capteurs tels que le LIDAR ou la caméra pour éviter les obstacles. Les informations collectées peuvent être utilisées pour ajuster la vitesse et la direction des moteurs connectés au module L298N. Ce module peut alors contrôler les moteurs pour faire avancer ou tourner le robot. En utilisant ces deux éléments, il est possible de construire un robot autonome capable de se déplacer de manière autonome en évitant les obstacles rencontrés.

Capteur HC-SR04

Le capteur HC-SR04 est un capteur de distance ultrasonique utilisé fréquemment dans les projets de robotique pour mesurer les distances à des objets. Il fonctionne en émettant un signal ultrasonique et en mesurant le temps qu’il faut pour que l’écho revienne au capteur. En utilisant la vitesse du son et le temps de voyage aller-retour, le capteur peut déterminer la distance à un objet.

Le capteur HC-SR04 est facile à utiliser et à intégrer dans des projets de robotique, car il dispose de quatre fils : alimentation, masse, déclenchement et écho. Il peut être contrôlé par une variété de contrôleurs électroniques, tels que la carte ESP32.

Les capteurs HC-SR04 sont utiles pour les robots qui doivent éviter les obstacles ou naviguer dans un environnement. Ils peuvent également être utilisés pour détecter les objets en mouvement, pour mesurer les distances à des objets, etc.

En résumé, le capteur HC-SR04 est un capteur de distance ultrasonique utile pour les projets de robotique qui nécessitent une mesure de distance à des objets. Il est facile à utiliser et à intégrer dans des projets grâce à ses quatre fils de connexion simples.

Servomoteur

Les servomoteurs sont souvent utilisés dans les projets de robotique pour contrôler la position et la vitesse de mouvement des objets. Ils peuvent être utilisés pour faire bouger des bras robotiques, des roues, des caméras, etc.

Un servomoteur peut être utilisé pour orienter la direction de détection des obstacles dans un robot détecteur d’obstacles. Le servomoteur peut être relié à un capteur ultrasonique tel que le HC-SR04 pour déterminer la distance à un objet.

Cela permet de couvrir une zone plus large et de fournir des informations plus complètes sur l’environnement de l’objet.

Lorsque le robot se déplace, le servomoteur peut être programmé pour faire pivoter le capteur ultrasonique dans différentes directions pour détecter les obstacles dans son environnement.

Moteur à courant continu de 5V

Un moteur à courant continu (CC) de 5 volts est un moteur électrique qui fonctionne à une tension de 5 volts. Les moteurs DC sont des moteurs qui utilisent un courant continu pour fonctionner et qui peuvent être alimentés par une variété de sources, notamment des piles, des panneaux solaires et des alimentations électriques.

Le module L298N et la carte ESP32 peuvent être utilisés ensemble pour contrôler des moteurs à courant continu (DC) dans un robot. La carte ESP32 peut être utilisée pour concevoir et exécuter le programme de contrôle du robot, tandis que le module L298N peut être utilisé pour contrôler la vitesse et la direction des moteurs. Les informations collectées à partir de capteurs de détection d’obstacles peuvent être utilisées pour ajuster la vitesse et la direction des moteurs en temps réel. Les moteurs à courant continu peuvent alors être utilisés pour faire avancer ou tourner le robot. Ce genre de configuration permet d’obtenir un robot autonome capable de se déplacer et d’éviter les obstacles rencontrés.

Les moteurs à courant continu de 5V sont disponibles en différentes tailles et puissances pour répondre à vos besoins en matière de performance. Ils peuvent être utilisés pour faire tourner des roues du robot.

Batterie de 9V

Une batterie de 9 volts est une pile qui fournit une tension de sortie de 9 volts. Elles sont souvent utilisées dans les appareils électroniques portables tels que les radiodiffuseurs, les jouets et les outils électroniques. Elles sont également couramment utilisées dans les applications de bricolage et de loisir, telles que les circuits électroniques et les projets de robotique.

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.

Kit robot voitures de 2 roues

Un kit robot voiture à deux roues est un ensemble de pièces et de composants qui permet de construire un robot mobile à deux roues. Ces kits sont généralement destinés aux débutants en robotique et sont conçus pour être faciles à utiliser et à assembler.

Les kits robot voiture à deux roues comprennent généralement un châssis de robot, des roues et des moteurs pour propulser le robot, ainsi qu’un contrôleur de moteur et un microcontrôleur pour commander le robot. Ils peuvent également inclure des capteurs et des modules de communication pour permettre au robot de naviguer et de détecter son environnement.

Pour utiliser un kit robot voiture à deux roues, il faut d’abord assembler le robot en suivant les instructions du manuel. Une fois le robot assemblé, vous pouvez le programmer pour qu’il effectue différentes tâches, comme suivre une ligne, éviter des obstacles ou se déplacer vers un emplacement précis.

Les kits robot voiture à deux roues sont une excellente introduction à la robotique et peuvent être utilisés pour enseigner la programmation et la robotique de manière interactive et ludique. Ils sont également idéaux pour les projets de loisirs et pour la création de robots de compétition.

Le kit robot utilisé dans ce projet est composé de :

châssis de voiture.
2 moteurs à engrenages
2 pneus de voiture
1 roue universelle

Pour assembler les composants du kit robot, vous pouvez voir cette vidéo.

Montage du robot

1- Pour le module L298N

Connecter la broche N°23 de la carte ESP32 à la broche ENA du module L298N.
Connecter la broche N°22 de la carte ESP32 à la broche IN1 du module L298N.
Connecter la broche N°21 de la carte ESP32 à la broche IN2 du module L298N.
Connecter la broche N°19 de la carte ESP32 à la broche IN3 du module L298N.
Connecter la broche N°18 de la carte ESP32 à la broche IN4 du module L298N.
Connecter la broche N°5 de la carte ESP32 à la broche ENB du module L298N.
Connecter la broche GND de la carte ESP32 à la broche GND du module L298N.
Connecter la broche 5V de la carte ESP32 à la broche (+) de la batterie 9V
Connecter la broche GND de la carte ESP32 à la borne (-) de la batterie 9V
Connecter la broche 12V du module L298N à la broche (+) de la batterie 9V
Connecter les deux moteurs de la voiture à la carte L298N

2- Pour le capteur HC-SR04 on connecte

La borne GND du capteur à la broche GND de la carte ESP32
La borne VCC du capteur à la broche 3.3V de la carte ESP32
La borne ECHO du capteur à la broche N°16 de la carte ESP32
La borne TRIG du capteur à la broche N°17 de la carte ESP32

3- Pour le servomoteur on connecte

On connecte le fil rouge du servomoteur à la borne (+) de la batterie 9V
On connecte le fil brun du servomoteur à la broche GND de la carte ESP32
On connecte le fil rouge du servomoteur à la broche N°15 de la carte ESP32

Programme Micropython

Voici le programme du robot commandé par la carte ESP32 qui détecte et évite les obstacles en utilisant un capteur de distance à ultrasons.

Il faut importer ces deux bliothèques : hcsr04 et DCMotor

from hcsr04 import HCSR04
from DCMotor import DCMotor 
import machine
from machine import Pin, PWM
import time
from time import sleep
frequency = 15000
# Connecter la carte ESP32 au module L298N
pin1 = Pin(22, Pin.OUT)    
pin2 = Pin(21, Pin.OUT)  
pin3 = Pin(19, Pin.OUT)    
pin4 = Pin(18, Pin.OUT)  
enable = PWM(Pin(23), frequency)  
enable1 = PWM(Pin(5), frequency)
dc_motor = DCMotor(pin1, pin2, enable)      
dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)
dc_motor1 = DCMotor(pin3, pin4, enable1)      
dc_motor1 = DCMotor(pin3, pin4, enable1, 350, 1023)
# Connecter le servomoteur à la carte ESP3
p15 = machine.Pin(15)
servo = machine.PWM(p15,freq=50)
servo.duty(70)
# Connecter le capteur HC-SR04 à la carte ESP32
sensor = HCSR04(trigger_pin=17,echo_pin=16,echo_timeout_us=1000000)

while True:
     distance = sensor.distance_cm() 
     print(distance,' cm')
     if (distance<20): # si le capteur HC-SR04 detecte un obstacle
      dc_motor.stop() # la voiture s arrete
      dc_motor1.stop()
      time.sleep_ms(1000)    
      dc_motor.backwards(100) # la voiture recule
      dc_motor1.backwards(100)
      time.sleep_ms(1000)
      dc_motor.stop() # la voiture s arrete
      dc_motor1.stop()
      time.sleep_ms(1000)
      for x in range(70,20,-1):# tourner le capteur HC-SR04 a droite
       servo.duty(x)
       time.sleep_ms(50)
      distance_droite = sensor.distance_cm() 
      time.sleep_ms(100)    
      for x in range(20,110): # tourner le capteur HC-SR04 à gauche
       servo.duty(x)
       time.sleep_ms(50)
      distance_gauche = sensor.distance_cm()       
      time.sleep_ms(1000)
      for x in range(110,70,-1):
       servo.duty(x)
       time.sleep_ms(100)       
      if (distance_gauche < distance_droite) : # comparer les deux distances pour choisir la bonne direction
       dc_motor1.forward(100) # la voiture tourne à droite
       time.sleep_ms(1000)
       dc_motor1.stop()
       time.sleep_ms(500)
      else:
       dc_motor.forward(100) # la voiture tourne à gauche     
       time.sleep_ms(1000)
       dc_motor.stop()
       time.sleep_ms(500)
     else:
      dc_motor.forward(100) # la voiture avance
      dc_motor1.forward(100)
     time.sleep_ms(100)

from hcsr04 import HCSR04

from DCMotor import DCMotor

import machine

from machine import Pin, PWM

import time

from time import sleep

frequency = 15000

# Connecter la carte ESP32 au module L298N

pin1 = Pin(22, Pin.OUT)

pin2 = Pin(21, Pin.OUT)

pin3 = Pin(19, Pin.OUT)

pin4 = Pin(18, Pin.OUT)

enable = PWM(Pin(23), frequency)

enable1 = PWM(Pin(5), frequency)

dc_motor = DCMotor(pin1, pin2, enable)

dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)

dc_motor1 = DCMotor(pin3, pin4, enable1)

dc_motor1 = DCMotor(pin3, pin4, enable1, 350, 1023)

# Connecter le servomoteur à la carte ESP3

p15 = machine.Pin(15)

servo = machine.PWM(p15,freq=50)

servo.duty(70)

# Connecter le capteur HC-SR04 à la carte ESP32

sensor = HCSR04(trigger_pin=17,echo_pin=16,echo_timeout_us=1000000)

while True:

distance = sensor.distance_cm()

print(distance,' cm')

if (distance<20): # si le capteur HC-SR04 detecte un obstacle

dc_motor.stop() # la voiture s arrete

dc_motor1.stop()

time.sleep_ms(1000)

dc_motor.backwards(100) # la voiture recule

dc_motor1.backwards(100)

time.sleep_ms(1000)

dc_motor.stop() # la voiture s arrete

dc_motor1.stop()

time.sleep_ms(1000)

for x in range(70,20,-1):# tourner le capteur HC-SR04 a droite

servo.duty(x)

time.sleep_ms(50)

distance_droite = sensor.distance_cm()

time.sleep_ms(100)

for x in range(20,110): # tourner le capteur HC-SR04 à gauche

servo.duty(x)

time.sleep_ms(50)

distance_gauche = sensor.distance_cm()

time.sleep_ms(1000)

for x in range(110,70,-1):

servo.duty(x)

time.sleep_ms(100)

if (distance_gauche < distance_droite) : # comparer les deux distances pour choisir la bonne direction

dc_motor1.forward(100) # la voiture tourne à droite

time.sleep_ms(1000)

dc_motor1.stop()

time.sleep_ms(500)

else:

dc_motor.forward(100) # la voiture tourne à gauche

time.sleep_ms(1000)

dc_motor.stop()

time.sleep_ms(500)

else:

dc_motor.forward(100) # la voiture avance

dc_motor1.forward(100)

time.sleep_ms(100)

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

Construction d’un robot commandé par la carte ESP32 qui détecte et évite les obstacles

Présentation du robot commandé par la carte ESP32 qui détecte et évite les obstacles:

Fonctionnement du robot:

Les composants nécessaires

Kit robot voitures de 2 roues

Montage du robot

Programme 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

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

Connecter Arduino UNO au réseau Wifi en utilisant le module ESP8266

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