Université Norbert La patrie ou la mort,

Zongo de Koudougou nous vaincrons

Conception et Simulation sur

Tinkercad d'un Système Embarqué
pour un Robot Autonome Évitant
les Obstacles

Réalisé par :

Nom Prénom INE

ZONGO Naboswende Guy-Roland E04545220211
BANCE Francois Xavier E00411120211

Licence 3 Informatique
Niveau : L3/S5

19 janvier 2025
Table des matières

1 Introduction 2
1.1 Contexte du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Objectifs du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Méthodologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.5 Structure du document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Composants et Matériels 4
2.1 Environnement de simulation : Tinkercad . . . . . . . . . . . . . . . . . . . 4
2.2 Liste des composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 Spécications du Robot 6
3.1 Description générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Fonctionnalités attendues . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4 Conception du Circuit 7
4.1 Composants utilisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.2 Étapes de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.3 Schéma nal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

5 Programmation 9
5.1 Logique du programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
5.2 Code source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

6 Résultats et Simulation 13
6.1 Tests réalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6.2 Analyse des résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

7 Dicultés et Améliorations 15
7.1 Problèmes rencontrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
7.2 Améliorations possibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

8 Conclusion 16

1
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 1
Introduction

1.1 Contexte du projet

La robotique mobile est un domaine en pleine expansion, mêlant ingénierie électro-
nique, programmation embarquée, et simulation virtuelle. Dans ce contexte, la capacité
des robots à détecter et éviter des obstacles constitue une compétence essentielle pour
leur navigation autonome dans des environnements dynamiques.
Ce projet s'inscrit dans le cadre de l'apprentissage des systèmes embarqués. Il a pour
objectif de simuler le fonctionnement d'un robot mobile capable de détecter et d'éviter des
obstacles, en exploitant la plateforme Tinkercad. Cet outil interactif permet de concevoir
et tester virtuellement des circuits électroniques, orant un environnement idéal pour
développer et expérimenter des solutions robotiques.

1.2 Problématique
Comment concevoir un robot mobile capable d'interagir ecacement avec son envi-
ronnement en détectant et en évitant les obstacles, tout en tirant parti des ressources de
simulation pour minimiser les coûts et les contraintes matérielles ? Cette problématique
guide la réalisation de ce projet, en mettant l'accent sur la faisabilité, la précision et
l'ecacité des solutions proposées.

1.3 Objectifs du projet

L'objectif principal de ce projet est de concevoir et de simuler un robot capable de
détecter des obstacles à l'aide d'un capteur infrarouge et de modier sa trajectoire en
conséquence. Ce travail vise également à renforcer les compétences en conception de cir-
cuits électroniques et en programmation embarquée.

1.4 Méthodologie
Pour atteindre ces objectifs, une approche structurée a été adoptée, comprenant les
étapes suivantes :
ˆ Conception du circuit électronique sur Tinkercad.
ˆ Programmation du microcontrôleur Arduino pour gérer les capteurs et les action-
neurs.

2
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

ˆ Simulation et tests du comportement du robot dans un environnement virtuel.

1.5 Structure du document

Ce document est organisé comme suit : le Chapitre 2 présente les composants utilisés,
le Chapitre 3 décrit les spécications du robot, et le Chapitre 4 détaille la conception du
circuit. Le Chapitre 5 explique la programmation du robot, tandis que les Chapitres 6
et 7 présentent respectivement les résultats des tests et les perspectives d'amélioration.
Enn, le Chapitre 8 conclut le projet en résumant les réalisations et en ouvrant sur des
perspectives futures.

3
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 2
Composants et Matériels

2.1 Environnement de simulation : Tinkercad

Tinkercad est une plateforme de conception et de simulation en ligne développée par
Autodesk. Elle permet de concevoir des circuits électroniques, de les simuler, et de pro-
grammer des microcontrôleurs tels que l'Arduino. Dans ce projet, Tinkercad a été utilisé
pour :
ˆ Concevoir le circuit électronique du robot.
ˆ Simuler le comportement du robot en temps réel.
ˆ Tester le code Arduino avant une implémentation sur du matériel physique.
La Figure 2.1 montre une capture d'écran de l'environnement Tinkercad.

Figure 2.1  Environnement Tinkercad.

2.2 Liste des composants

Deux moteurs à courant continu Ils servent de roues motrices, assurant les dé-
placements du robot en avant, en arrière et en rotation.
Un capteur infrarouge Ce capteur détecte les obstacles en mesurant la réexion
du signal infrarouge.

4
Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Microcontrôleur Arduino Uno Il est au c÷ur du système, contrôlant les moteurs

et recevant les signaux du capteur.
Pilote de moteur L293D Il permet de gérer la puissance et le sens de rotation des
moteurs à courant continu.
Écran LCD Il ache des informations sur l'état du robot, comme les détections
d'obstacles ou les changements de direction.
Potentiomètre Il règle le contraste de l'écran LCD pour une meilleure lisibilité.
Batterie 9V Elle alimente les moteurs via le pilote de moteur.
Bouton poussoir en pull-down Utilisé pour simuler un obstacle lors des tests du
capteur infrarouge.
Résistances Une résistance est utilisée pour le bouton poussoir en pull-down, l'autre
pour l'anode du rétroéclairage de l'écran LCD.
Câbles de connexion et platine d'expérimentation Pour assembler les compo-
sants et tester le circuit.

5
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 3
Spécications du Robot

3.1 Description générale

Le robot est constitué des éléments suivants, décrits en détail dans la Section 2.2 :
ˆ Deux moteurs à courant continu (roues motrices)
ˆ Un capteur infrarouge
ˆ Microcontrôleur Arduino Uno
ˆ Source d'alimentation
ˆ Écran LCD
ˆ Potentiomètre
ˆ Pilote de moteur L293D
ˆ Platine d'expérimentation
ˆ Bouton poussoir (en pull-down)
ˆ Résistances

3.2 Fonctionnalités attendues

Le robot doit être capable de :
ˆ Détecter les obstacles à l'aide du capteur infrarouge.
ˆ Modier sa trajectoire pour éviter les obstacles en tournant à gauche ou à droite.
ˆ Acher son état (en mouvement, obstacle détecté, changement de direction) sur
un écran LCD.

6
Chapitre 4
Conception du Circuit

4.1 Composants utilisés

Les composants utilisés dans ce chapitre sont décrits en détail dans la Section 2.2.

4.2 Étapes de conception

La conception du circuit a été réalisée de manière structurée et progressive, en respec-
tant les étapes suivantes :
1. Ajout des composants dans l'interface de Tinkercad : Les composants dé-
crits précédemment ont été placés sur la platine.
2. Connexion des moteurs au pilote L293D : Les deux moteurs ont été reliés
aux sorties correspondantes du L293D pour permettre leur contrôle par l'Arduino.
3. Connexion du capteur infrarouge : Le capteur a été branché à une entrée
numérique de l'Arduino pour transmettre les signaux détectés.
4. Installation de l'écran LCD : Les broches de l'écran LCD ont été connectées à
l'Arduino, avec un potentiomètre pour ajuster le contraste.
5. Conguration du bouton poussoir : Un bouton poussoir monté en pull-down
a été ajouté pour simuler des obstacles dans l'environnement du robot.
6. Intégration de l'alimentation : La batterie 9V a été connectée au L293D pour
alimenter les moteurs, tandis que l'Arduino est alimenté via USB ou une source
externe.

4.3 Schéma nal

Le schéma nal, conçu et simulé sur Tinkercad, illustre les connexions suivantes :
ˆ Les connexions des moteurs au pilote L293D, pour un contrôle bidirectionnel.
ˆ Le branchement du capteur infrarouge à une entrée numérique de l'Arduino.
ˆ L'écran LCD connecté à l'Arduino, avec un potentiomètre pour ajuster son contraste.
ˆ Le montage du bouton poussoir en pull-down, permettant de simuler la détection
d'obstacles.
ˆ La connexion de la batterie 9V pour alimenter les moteurs indépendamment de
l'Arduino.

7
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

La Figure ?? présente le schéma schématique du circuit, montrant les connexions entre

les composants essentiels.

Figure 4.1  Vue schématique du circuit du robot.

8
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 5
Programmation

5.1 Logique du programme

Le programme repose sur l'algorithme suivant :
1. Lire les données du capteur infrarouge.
2. Si un obstacle est détecté :
ˆ Arrêter le robot.
ˆ Modier la direction (tourner à gauche ou à droite).
ˆ Reprendre le déplacement.
3. Sinon, continuer tout droit.

5.2 Code source

Voici le code complet permettant au robot d'éviter les obstacles. Le Listing 5.1 présente
le programme Arduino implémentant la logique de détection et d'évitement d'obstacles.

Listing 5.1  Code Arduino pour le robot évitant les obstacles

1 # include < LiquidCrystal .h > // Bibliotheque pour l ' ecran LCD
2
3 // Definition des broches de l ' ecran LCD
4 const int rs = 7 , en = 8 , d4 = 9 , d5 = 10 , d6 = 11 , d7 =
12;
5 LiquidCrystal lcd (rs , en , d4 , d5 , d6 , d7 ) ;
6
7 // Definition des broches pour les moteurs
8 const int IN1 = 4; // IN1 du L293D ( Moteur 2 - Roue gauche
)
9 const int IN2 = 5; // IN2 du L293D ( Moteur 2 - Roue gauche
)
10 const int IN3 = 2; // IN3 du L293D ( Moteur 1 - Roue droite
)
11 const int IN4 = 3; // IN4 du L293D ( Moteur 1 - Roue droite
)
12
13 // Definition de la broche du capteur infrarouge
14 const int irSensor = 6; // Broche du capteur infrarouge

9
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

15
16 // Variable pour suivre l ' etat precedent du capteur
17 int previousObstacleState = LOW ;
18
19 void setup () {
20 // Initialisation de l ' ecran LCD
21 lcd . begin (16 , 2) ; // 16 colonnes , 2 lignes
22 lcd . print (" Robot en attente ") ;
23
24 // Configuration des broches
25 pinMode ( IN1 , OUTPUT );
26 pinMode ( IN2 , OUTPUT );
27 pinMode ( IN3 , OUTPUT );
28 pinMode ( IN4 , OUTPUT );
29 pinMode ( irSensor , INPUT ) ;
30
31 // Initialiser la communication serie
32 Serial . begin (9600) ;
33
34 // Afficher l ' etat initial
35 afficherEtat ( LOW ) ; // Afficher " En mouvement " si
aucun obstacle n ' est detecte
36 }
37
38 void loop () {
39 // Lire l ' etat du capteur infrarouge
40 int obstacle = digitalRead ( irSensor );
41 Serial . print (" Etat du capteur : " );
42 Serial . println ( obstacle ) ;
43
44 // Verifier si l ' etat du capteur a change
45 if ( obstacle != previousObstacleState ) {
46 afficherEtat ( obstacle ); // Mettre a jour l '
affichage
47 previousObstacleState = obstacle ; // Mettre
a jour l ' etat precedent
48 }
49
50 // Controler le robot en fonction de l ' etat du
capteur
51 if ( obstacle == HIGH ) {
52 // Obstacle detecte : arreter et changer de
direction
53 arreterRobot () ;
54 delay (100) ; // Pause avant de tourner
55 tournerGauche () ; // ou tournerDroite () ;
56 avancer () ; // Reprendre le mouvement
57 } else {
58 // Pas d ' obstacle : avancer
59 avancer () ;
60 }

10
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

61 }
62
63 // Fonction pour mettre a jour l ' affichage
64 void afficherEtat ( int obstacle ) {
65 lcd . clear () ;
66 if ( obstacle == HIGH ) {
67 lcd . print (" Obstacle detecte ");
68 lcd . setCursor (0 , 1) ;
69 lcd . print (" Changement dir . ");
70 } else {
71 lcd . print (" En mouvement ");
72 lcd . setCursor (0 , 1) ;
73 lcd . print (" Direction : Avant ");
74 }
75 }
76
77 // Fonction pour faire avancer le robot
78 void avancer () {
79 digitalWrite ( IN1 , HIGH ); // Moteur 1 ( Roue gauche )
tourne en avant
80 digitalWrite ( IN2 , LOW );
81 digitalWrite ( IN3 , HIGH ); // Moteur 2 ( Roue droite )
tourne en avant
82 digitalWrite ( IN4 , LOW );
83 }
84
85 // Fonction pour arreter le robot
86 void arreterRobot () {
87 digitalWrite ( IN1 , LOW ); // Moteur 1 ( Roue gauche )
arrete
88 digitalWrite ( IN2 , LOW );
89 digitalWrite ( IN3 , LOW ); // Moteur 2 ( Roue droite )
arrete
90 digitalWrite ( IN4 , LOW );
91 }
92
93 // Fonction pour tourner a gauche
94 void tournerGauche () {
95 digitalWrite ( IN1 , LOW ); // Moteur 1 ( Roue gauche )
arrete ou tourne en arriere
96 digitalWrite ( IN2 , HIGH );
97 digitalWrite ( IN3 , HIGH ); // Moteur 2 ( Roue droite )
tourne en avant
98 digitalWrite ( IN4 , LOW );
99 delay (500) ; // Temps pour tourner
100 }
101
102 // Fonction pour tourner a droite
103 void tournerDroite () {
104 digitalWrite ( IN1 , HIGH ); // Moteur 1 ( Roue gauche )
tourne en avant

11
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

105 digitalWrite ( IN2 , LOW );

106 digitalWrite ( IN3 , LOW ); // Moteur 2 ( Roue droite )
arrete ou tourne en arriere
107 digitalWrite ( IN4 , HIGH );
108 delay (500) ; // Temps pour tourner
109 }

12
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 6
Résultats et Simulation

6.1 Tests réalisés

Les tests suivants ont été eectués dans l'environnement de simulation Tinkercad pour
valider le fonctionnement du robot :
ˆ Détection d'obstacles à l'aide du capteur infrarouge, simulée par l'appui sur un
bouton poussoir.
ˆ Modication de la direction du robot pour éviter les obstacles détectés.
ˆ Vérication de l'achage des états du robot sur l'écran LCD, tels que :
 En mouvement - Direction : Avant lors du déplacement normal.
 Obstacle détecté - Changement de direction lors de la détection d'un
obstacle.
La Figure 6.1 illustre le montage simulé du circuit sur la plateforme Tinkercad.

Figure 6.1  Montage du circuit simulé sur Tinkercad.

6.2 Analyse des résultats

Les simulations ont permis de vérier que le robot remplit les fonctionnalités attendues.
Les résultats obtenus sont les suivants :

13
Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

ˆ Détection et évitement des obstacles : Le robot détecte les obstacles simulés

par le bouton poussoir et modie ecacement sa direction.
ˆ Achage clair des états : L'écran LCD indique avec précision les diérentes
étapes, notamment le mouvement normal et les réactions face à un obstacle.

14
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 7
Dicultés et Améliorations

7.1 Problèmes rencontrés

Lors de la conception et des tests dans l'environnement virtuel Tinkercad, plusieurs
dés ont été identiés :
ˆ Simulation d'obstacles physiques : Tinkercad étant limité à une interface 2D,
il est dicile de représenter et de tester de vrais obstacles. Pour pallier cela, un
bouton poussoir a été utilisé pour simuler la présence d'un obstacle devant le robot.
ˆ Calibration du capteur infrarouge : Assurer une détection précise dans un
environnement virtuel s'est révélé complexe, nécessitant des ajustements manuels
des paramètres.
ˆ Erreurs dans la simulation : Parfois, des connexions électriques instables ou des
comportements inattendus ont été observés, ce qui perturbait le fonctionnement
prévu du circuit.

7.2 Améliorations possibles

Pour surmonter ces limitations et améliorer la performance globale du robot, plusieurs
pistes peuvent être envisagées :
ˆ Utilisation d'une plateforme plus avancée : Intégrer une plateforme de si-
mulation plus robuste et en 3D, comme Gazebo ou Webots, pourrait permettre de
tester le comportement du robot face à de vrais obstacles modélisés en 3D.
ˆ Renforcement des tests matériels : Construire un prototype physique du ro-
bot pour valider le fonctionnement réel du capteur infrarouge, des moteurs et de
l'algorithme de détection et d'évitement des obstacles.
Ces propositions visent à améliorer à la fois la précision, la abilité et la polyvalence
du robot, tout en prenant en compte les limites techniques de l'environnement virtuel
Tinkercad.

15
 Conception et Simulation sur Tinkercad d'un Système Embarqué pour un
Robot Autonome Évitant les Obstacles

Chapitre 8
Conclusion
Ce projet a permis de simuler un robot capable de détecter et d'éviter des obstacles
sur Tinkercad. Les objectifs xés ont été atteints avec succès, malgré les dés techniques
rencontrés lors de la conception et de la simulation. Ce travail a permis d'acquérir et de
consolider des compétences essentielles en conception de circuits électroniques, en pro-
grammation embarquée et en simulation virtuelle.
Comme perspectives d'amélioration, il serait intéressant de tester ce projet avec des
composants réels pour valider son fonctionnement dans un environnement physique. De
plus, l'utilisation de techniques d'intelligence articielle (IA) pourrait être explorée pour
optimiser le code, par exemple en implémentant des algorithmes d'apprentissage auto-
matique an d'améliorer la détection d'obstacles et la prise de décision du robot. Ces
évolutions permettraient de rendre le système plus performant et adaptatif.

16