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 Arduino qui détecte et évite les obstacles:
Un robot qui utilise une carte Arduino pour détecter et éviter les obstacles peut être construit en
utilisant des capteurs d’obstacles tels que des capteurs de distance infrarouges ou des capteurs
ultrasons. Les données recueillies par les capteurs sont analysées par la carte Arduino, qui détermine
la direction dans laquelle le robot doit tourner pour éviter l’obstacle. Le mouvement du robot peut être
contrôlé en utilisant des servomoteurs ou des moteurs DC connectés à la carte Arduino. Le code pour
faire fonctionner ce robot peut être écrit en utilisant le langage de programmation Arduino.
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 :
1. Initialisation : le robot est allumé et les différents composants sont initialisés, notamment les
capteurs, les moteurs, et la carte Micro:bit.
2. Collecte de données : le capteurs HC-SR04 collecte des informations sur l’environnement
du robot, telles que la distance à des obstacles.
3. Analyse des données : la carte Arduino analyse les données collectées par les capteurs pour
déterminer la présence et la distance d’un obstacle.
4. Prise de décision : en fonction des informations collectées et analysées, la
carte Arduino décide de la meilleure façon d’éviter l’obstacle.
5. Contrôle des moteurs : la carte Arduino envoie des commandes aux moteurs pour effectuer les
mouvements nécessaires pour éviter l’obstacle.
6. 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 Arduino UNO

L’Arduino UNO est une carte de développement

populaire basée sur un microcontrôleur AVR. Il
possède 14 broches d’entrée/sortie numériques, 6
broches analogiques, un port série, un port USB et un
port de alimentation. Il peut être programmé en utilisant
le langage de programmation Arduino et est compatible
avec un grand nombre de capteurs et d’accessoires.
L’Arduino UNO est souvent utilisé pour des projets de
robotique, d’automatisation, d’Internet des objets (IoT)
et d’applications d’apprentissage de l’électronique.
Module L293D
Module L293D – Contrôle Pour moteur DC 40dh
Moteur DC et Moteur Pas à Pas
55dh

Le module L293D est un driver de moteur bidirectionnel pour alimenter les moteurs DC, les moteurs
pas à pas et les moteurs à courant continu. Il peut alimenter jusqu’à 2 moteurs DC avec une tension
d’entrée de 4,5 à 36 volts. Le L293D est équipé de 4 broches pour contrôler la direction et la vitesse
des moteurs, ainsi que de 2 broches pour alimenter les moteurs. Ce module est souvent utilisé avec des
cartes de développement telles que l’Arduino pour contrôler les mouvements des robots et d’autres
dispositifs mécaniques.
Le module L293D peut être utilisé pour contrôler les mouvements des robots en utilisant une carte de
développement telle que l’Arduino. Le module peut être connecté à la carte Arduino via les broches de
commande, tandis que les moteurs du robot peuvent être connectés aux broches de sortie du module.
Le code peut être écrit en utilisant le langage de programmation Arduino pour contrôler la direction et
la vitesse des moteurs via les broches du module L293D. De cette façon, le robot peut être
programmé pour se déplacer dans différentes directions et à différentes vitesses pour accomplir
diverses tâches.
Capteur HC-SR04 27dh

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 Arduino.
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
 rouge : pour l’alimentation positive (4.5V à 6V en général)
 noir ou marron : pour la masse (0V)
 orange, jaune, blanc, … : entrée du signal de commande
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.
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.
2 Moteurs à courant continu de 5V vendu avec le kit

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 L293D et la carte Arduino peuvent être utilisés ensemble pour contrôler des
moteurs à courant continu (DC) dans un robot. La carte Arduino peut être utilisée pour
concevoir et exécuter le programme de contrôle du robot, tandis que le module L293D 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.
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 à la
carte Arduino. Ils sont généralement utilisés pour connecter
des capteurs, des actionneurs, des afficheurs et d’autres
composants à la carte Arduino 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.

Kit robot voitures de 2 roues chasis et 2 moteurs : (179dh chez microMaroc)

https://micromaroc.com/products/voiture-2wd

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 capteur HC-SR04 on connecte

 La borne GND du capteur à la broche GND de la carte Arduino

 La borne VCC du capteur à la broche 3.3V de la carte Arduino
 La borne ECHO du capteur à la broche N°7 de la carte Arduino
 La borne TRIG du capteur à la broche N°4 de la carte Arduino
2- On branche le module L293D à la carte Arduino
3- On connecte le servomoteur au module L293D
Montage :
Code arduino :
#include <HCSR04.h>
#include <AFMotor.h>
#include <Servo.h>
Servo myservo; // create servo object to control a servo
AF_DCMotor motor1(3); // connecter les deux moteurs des roues du robot au module L293D
AF_DCMotor motor2(4);
// definition des broches du capteur HC-SR04
const int trigPin = 4;
const int echoPin = 7;
int distance,distance_droite,distance_gauche;
int pos;
// initialisation du capteur avec les broches utilisees.
UltraSonicDistanceSensor distanceSensor(trigPin, echoPin);
void setup() {
myservo.write(90); // tell servo to go to position 90
myservo.attach(10); // attaches the servo on pin 10 to the servo object
motor1.setSpeed(100);
motor2.setSpeed(100);
// initialisation du port serie a 9600 band pour afficher les valeurs mesurees par le capteur.
Serial.begin(9600);
}

void loop() {
distance = distanceSensor.measureDistanceCm();
Serial.println(distance);
delay(50);
if ((distance<15)and(distance>0)){ // le capteur HC-SR04 détecte un obstacle
motor1.run(RELEASE); // le robot s'arrete
motor2.run(RELEASE);
delay(500);
motor1.run(BACKWARD); // le robot recule
motor2.run(BACKWARD);
delay(500);
motor1.run(RELEASE); // le robot s'arrete
motor2.run(RELEASE);

for (pos = 90; pos > 10; pos -= 1) { // Faire tourner le capteur HC-SR04 vers la droite
myservo.write(pos);
delay(15);
}
delay(500);
distance_droite = distanceSensor.measureDistanceCm(); // calculer la distance entre le capteur HC-
SR04 et un obstacle s'il existe
delay(500);
for (pos = 0; pos < 170; pos += 1) { // Faire tourner le capteur HC-SR04 à gauche
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
delay(500);
distance_gauche = distanceSensor.measureDistanceCm();// calculer la distance entre le capteur HC-
SR04 et un obstacle s'il existe
delay(500);

for (pos = 170; pos > 90; pos -= 1) { // retour à la position initiale
myservo.write(pos);
delay(15);
delay(500);
}
if (distance_droite<distance_gauche){
motor2.run(FORWARD); // faire tourner le robot à gauche
delay(1000);
motor2.run(RELEASE);
delay(500);
} else {
motor1.run(FORWARD); // aire tourner le robot à droite
delay(1000);
motor1.run(RELEASE);
delay(500);
}
}
else if (distance>0) {
motor1.run(FORWARD); // faire avancer la voiture
motor2.run(FORWARD);
}
}
 Robot commandé par téléphone portable
Le module contrôleur de moteur L293D est un module
électronique utilisé pour contrôler des moteurs électriques DC
ou des moteurs pas à pas. Il est doté de quatre canaux de
commande de moteur qui peuvent être utilisés
indépendamment ou en tandem pour contrôler jusqu’à quatre
moteurs.
Programme Arduino
Voici le programme qui permet de connecter la carte Arduino au smartphone et de recevoir un
message contenant l’ordre de commandement de la voiture.

1 #include <SoftwareSerial.h>

2 #include <AFMotor.h>

4 AF_DCMotor motor1(3);

5 AF_DCMotor motor2(4);

6 SoftwareSerial hc06(2,3);

7 String cmd="";

9 void setup(){

10 motor1.setSpeed(150);

11 motor2.setSpeed(150);

12

13 //Initialize Serial Monitor

14 Serial.begin(9600);
15 //Initialize Bluetooth Serial Port

16 hc06.begin(9600);

17 }

18

19 void loop(){

20

21 //Read data from HC06

22 while(hc06.available()>0){

23 cmd+=(char)hc06.read();

24 }

25

26 //Select function with cmd

27 if(cmd!=""){

28 Serial.print("Command recieved : ");

29 Serial.println(cmd);

30 // We expect ON or OFF from bluetooth

31 if(cmd=="avant"){

32 motor1.run(FORWARD); // faire avancer la voiture

33 motor2.run(FORWARD);

34 }

35 if(cmd=="arriere"){

36 motor1.run(BACKWARD);// faire reculer la voiture

37 motor2.run(BACKWARD);

38 }

39 if(cmd=="gauche"){

40 motor1.run(FORWARD); // faire tourner la voiture à gauche

41 }

42 if(cmd=="droite"){

43 motor2.run(FORWARD); // faire tourner la voiture à droite

44 }
45 if(cmd=="stop"){

46 motor1.run(RELEASE); // arrêter la voiture

47 motor2.run(RELEASE);

48 }

49

50 cmd=""; //reset cmd

51 }

52

53 delay(100);

54 }

Application pour portabel a telecharger sur apple stor : Arduino Bluetooth Control