Université Ibn Tofaïl

Faculté des Sciences - Kénitra-

Département Physique

Master 2 « Electronique Embarquée »

Mini projet : SE-avec Cloud
Module : Système embarqué

Réalisé par :
BOULAKOUCH Yousra
ANTAR Aya
ELGOURT Salma

Sous le thème :

Robot détecteur d’obstacle avec ros, Node-Red, Fire-base

et MIT app inventor

Encadré par : Pr. ADNANI

Année Universitaire : 2024/2025

Table des matières
Introduction................................................................................................................................................................................................. 4
Objectif du projet :.................................................................................................................................................................................... 5
Utilisations possibles de ce projet : ..................................................................................................................................................... 5
I. ROS ..................................................................................................................................................................................................... 6
1. Introduction .................................................................................................................................................................................. 6
2. Définition et concept.................................................................................................................................................................. 7
3. Fonctionnalités ............................................................................................................................................................................ 7
4. Composants principaux de ROS ............................................................................................................................................ 7
5. Architecture de communication ............................................................................................................................................. 8
6. Principales caractéristiques du ROS ................................................................................................................................... 8
7. ROS et la robotique.................................................................................................................................................................... 9
8. Différences entre ROS1 et ROS2 ........................................................................................................................................... 9
9. Composants principaux de ROS en détail ........................................................................................................................ 10
10. Installation de ROS2........................................................................................................................................................... 11
a. Prérequis .................................................................................................................................................. 11
b. Installation de ROS2 ............................................................................................................................... 11
c. Configurer l'environnement ROS2 .......................................................................................................... 12
d. Vérifier l'installation ................................................................................................................................ 12
7. Conclusion ....................................................................................................................................................................................... 12
II. Node-Red ......................................................................................................................................................................................... 13
1. Présentation du Node-Red ..................................................................................................................................................... 13
2. Fonctionnalités principales : ................................................................................................................................................ 13
3. Schéma fonctionnel de Node-RED ...................................................................................................................................... 13
3. Node-RED et ROS .................................................................................................................................................................... 14
4. Node-RED et Arduino : Le Contrôle Matériel ................................................................................................................ 14
4. Node-RED dans un Projet Robotique ................................................................................................................................ 15
5. Configuration Node-RED projet.......................................................................................................................................... 15
6. Conclusion .................................................................................................................................................................................. 16
III. Firebase........................................................................................................................................................................................ 16
1. Définition .................................................................................................................................................................................... 16
2. Fonctionnalités principales de Firebase : .......................................................................................................................... 16
Avantages de Firebase : ................................................................................................................................ 17
IV. MIT App inventer..................................................................................................................................................................... 19
1. Définition .................................................................................................................................................................................... 19
V. ARDUINO IDE ............................................................................................................................................................................. 22
1. Présentation du logiciel.......................................................................................................................................................... 22
2. Structure d’un programme .................................................................................................................................................... 23
VI. Partie Materiel ........................................................................................................................................................................... 24
1. Robot mobile .............................................................................................................................................................................. 24
a) Châssis de robot avec roues et moteurs. .................................................................................................. 24

2
 b) Moteurs DC ............................................................................................................................................. 24
c) Contrôleur de moteur L298N .................................................................................................................. 25
2. Carte microcontrôleur Arduino UNO ................................................................................................................................ 26
3. Capteurs ...................................................................................................................................................................................... 26
Capteur à ultrasons (HC-SR04) pour détecter les obstacles. ........................................................................... 26
4. Module de communication..................................................................................................................................................... 27
Module Bluetooth (HC-05 ou HC-06) ............................................................................................................ 27
5. Source d'énergie ....................................................................................................................................................................... 28
6. Divers ........................................................................................................................................................................................... 28
7. Schéma électrique du robot ................................................................................................................................................... 28
Conclusion ................................................................................................................................................................................................ 29
Annexe ....................................................................................................................................................................................................... 30
Liens utiles et références.................................................................................................................................................................. 30
Codes de projet ................................................................................................................................................................................... 30
Commandes pour la communication du Bluetooth et le démarrage du robot ................................................................. 34

3
 Introduction

Ce projet a pour objectif de concevoir et développer un robot mobile détecteur d'obstacles, contrôlable
via une application mobile créée avec MIT App Inventor. Le robot repose sur une architecture
combinant Arduino, ROS (Robot Operating System) et Node-RED, permettant une gestion optimisée
des commandes et des capteurs.
Le robot est équipé d'un capteur ultrason HC-SR04 pour détecter les obstacles et d'un module Bluetooth
HC-05 pour la communication avec l’application mobile. Lorsqu’un obstacle est détecté, un message
d’alerte accompagné d’une image s’affiche directement sur l’application, offrant ainsi un retour visuel
instantané à l’utilisateur.
L’intégration de ROS et Code-RED dans ce projet permet une gestion modulaire des données en
facilitant la communication entre les différents composants du robot. ROS est utilisé pour structurer et
traiter les informations des capteurs, tandis que Code-RED automatise certaines actions et simplifie
l’interface de gestion des commandes.
Ce rapport détaille les différentes étapes du projet, allant du choix du matériel et de l’assemblage du
robot jusqu’à la programmation sous Arduino, l’intégration de ROS et la configuration de Code-RED.
Les tests réalisés permettront d’évaluer les performances du système et d’identifier les améliorations
possibles.

4
Objectif du projet :
Un robot détecte les obstacles grâce à un capteur à ultrasons et envoie ces données au cloud pour
affichage ou analyse en temps réel via une application mobile. L'utilisateur peut également surveiller les
données à distance et contrôler le robot.

 Fonctionnalité principale :

Créer un robot autonome capable de détecter des obstacles dans son environnement grâce à un capteur à
ultrasons et de réagir en conséquence (par exemple, s'arrêter, changer de direction, ou envoyer des alertes).

 Connectivité au cloud :

Les données capturées par le robot (comme la distance des obstacles, l'état des moteurs, ou la localisation
éventuelle) sont envoyées au cloud (Firebase). Cela permet de :

 Superviser à distance le fonctionnement du robot à partir d’une application mobile.

 Enregistrer et analyser les données dans une base de données pour une utilisation ultérieure.

 Contrôle à distance :

Grâce à l'application mobile développée avec MIT App Inventor :

 L'utilisateur peut surveiller en temps réel les données (distance des obstacles, statut du robot).
 Il peut aussi envoyer des commandes à distance pour contrôler le robot via Bluetooth ou via le
cloud (Firebase).

 Automatisation et intégration :

En utilisant des outils comme Node-RED et ROS, le projet permet :

 Une automatisation des tâches (par exemple, si un obstacle est détecté, le robot peut
automatiquement arrêter ses moteurs).
 Une communication fluide entre les différents systèmes (Arduino, ROS, Firebase, application
mobile).

Utilisations possibles de ce projet :

Éducation :

o Apprendre les bases de la robotique, des systèmes embarqués, et des technologies cloud.
o Comprendre l’intégration des capteurs, la communication Bluetooth, et les API cloud.

5
Recherche :

o Étudier la navigation autonome et la détection d’obstacles.

o Tester les performances de capteurs dans différents environnements.

Applications réelles :

o Robots domestiques : Robots aspirateurs, tondeuses.

o Surveillance : Détection d’obstacles dans des espaces difficiles à atteindre.

Robots industriels : Robots mobiles utilisés dans les entrepôts.

Projets IoT (Internet des Objets) :

o Montrer comment intégrer des dispositifs physiques (robot) avec des services cloud pour
un contrôle et une surveillance en temps réel.

I. ROS

1. Introduction
Le système d'exploitation ROS (Robot Operating System) est une plateforme de développement
largement utilisée pour la programmation de robots. C’est un ensemble d'outils, de bibliothèques et de
conventions permettant de simplifier la création d’applications robotiques complexes. ROS n’est pas un
système d’exploitation en tant que tel, mais plutôt une couche d'abstraction entre le matériel du robot et
les logiciels. Il facilite la communication entre les différents composants du robot, comme les capteurs,
les moteurs, les algorithmes de contrôle, etc.

6
 2. Définition et concept
Robot Operating System (ROS), est un ensemble d'outils informatiques sous forme de logiciels libres (le
système est sous licence BSD) open source, permettant de développer des logiciels pour la robotique.
C’est un middleware qui fournit des services comme la gestion des communications interprocessus, la
gestion des périphériques, des bibliothèques logicielles pour la manipulation de capteurs, et des outils
pour la visualisation des données et des résultats.

3. Fonctionnalités
ROS regroupe plusieurs fonctionnalités qui facilitent le développement d'applications souples et
modulables pour la robotique.

 Architecture de communication interprocessus et inter-machine

 Serveur de paramètre
 Système d'enregistrement et de rejeu
 Système de test
 Simulateur (Gazebo)

4. Composants principaux de ROS

 Nœuds : Ce sont des programmes ou des processus qui exécutent des fonctions spécifiques sur le robot
(par exemple, la lecture des capteurs, le contrôle des moteurs, etc.). Un nœud peut être écrit en Python,
C++ ou d'autres langages compatibles.
 Topics : Ce sont des canaux de communication utilisés pour transmettre des messages entre nœuds.
Par exemple, un nœud peut publier des données (comme les valeurs d'un capteur) sur un topic, et un
autre nœud peut s'abonner à ce topic pour recevoir les données.
 Messages : Les informations échangées entre nœuds via des topics. Chaque message a une structure
spécifique définie dans ROS. Il peut s'agir de données comme des coordonnées, des images ou des
états.
 Services : Contrairement aux topics qui permettent une communication asynchrone, un service est une
communication synchrone entre deux nœuds. Un nœud envoie une demande et attend une réponse.
 Paramètres : Les paramètres sont utilisés pour stocker des données de configuration globales
accessibles par tous les nœuds.

7
 Actions : Une abstraction plus avancée pour gérer des tâches longue durée où le nœud peut recevoir
des retours intermédiaires tout en continuant à exécuter une tâche.

5. Architecture de communication
ROS offre une architecture souple de communication interprocessus et inter-machine. Les processus ROS
sont appelés des nœuds et chaque nœud peut communiquer avec d'autres via des topics. La connexion
entre les nœuds est gérée par un master et suit le processus suivant :

1. Un premier nœud avertit le master qu'il a une donnée à partager

2. Un deuxième nœud avertit le master qu'il souhaite avoir accès à une donnée
3. Une connexion entre les deux nœuds est créée
4. Le premier nœud peut envoyer des données au second

Un nœud qui publie des données est appelé un Publisher et un nœud qui souscrit à des données est appelé
un subscriber. Un nœud peut être à la fois publisher et subscriber. Les messages envoyés sur les topics
sont pour la plupart standardisés ce qui rend le système extrêmement flexible.

ROS permet une communication inter-machine, des nœuds s'exécutant sur des machines distinctes, mais
ayant connaissance du même master peuvent communiquer de manière transparente pour l'utilisateur.

6. Principales caractéristiques du ROS

 Modularité : ROS est connu pour sa conception modulaire, qui permet aux développeurs d’intégrer
facilement divers composants logiciels et matériels. Cette modularité facilite la réutilisation du code
dans différents projets, ce qui accélère considérablement le processus de développement.

 Outils et bibliothèques : ROS offre de nombreux outils et bibliothèques qui aident à construire et à
simuler des applications robotiques complexes. Ces outils permettent d’effectuer des tâches allant de
la visualisation, de la simulation et de la navigation à la perception, qui sont cruciales pour développer
le comportement des robots intelligents.

 Communauté et soutien : L’une des plus grandes forces du ROS est sa communauté dynamique. Des
milliers de développeurs à travers le monde contribuent à ROS, créant un riche référentiel de

8
 bibliothèques, d’outils et de tutoriels. Ce soutien communautaire fait de ROS une ressource
inestimable pour les ingénieurs en robotique, qu’ils soient débutants ou expérimentés.

7. ROS et la robotique

 ROS facilite la gestion des capteurs (lidar, caméra, IMU), des actionneurs (moteurs, bras robotiques)
et des algorithmes complexes nécessaires pour les robots.
 ROS est largement utilisé dans la recherche académique, mais aussi dans l'industrie, notamment dans
les robots mobiles, la robotique industrielle, les drones, et les véhicules autonomes.

8. Différences entre ROS1 et ROS2

ROS1 était la version initiale de ROS, largement adoptée dans la recherche et l'industrie. Cependant, il
présente certaines limitations majeures, telles que la gestion des ressources, l'absence de support natif pour

les communications en tem temps réel et un modèle de communication peu flexible pour les applications
distribuées.

ROS2 a été conçu pour répondre à ces limitations. Il est basé sur le DDS (Data Distribution Service),
un standard pour la communication distribuée qui offre des avantages en termes de scalabilité, sécurité,
et gestion des délais.

Comparaison détaillée entre ROS1 et ROS2

Caractéristique ROS1 ROS2
Gestion des TCP/IP (limitée en termes de QoS) DDS (plus flexible, supporte plusieurs
communications qualités de service)
Support des systèmes Principalement Linux, avec un Linux, Windows, macOS, Android
d'exploitation support limité pour Windows et
macOS
Temps réel Pas de support natif Support natif du temps réel (RTOS)
Sécurité Pas de mécanisme de sécurité Sécurité renforcée (authentification,
cryptage)
Scalabilité Limité dans les systèmes distribués Plus robuste pour les applications
distribuées
Modèle de Modèle de communication Amélioration du modèle avec DDS pour
communication synchrone et asynchrone avec une meilleure performance réseau
limitations

Conclusion : ROS2 est désormais la version recommandée pour les nouveaux projets, car il est plus
moderne, plus performant et mieux adapté aux applications industrielles

9
 9. Composants principaux de ROS en détail
 Roscore

C’est le processus maître de ROS, indispensable pour faire fonctionner un système ROS. Il initialise le
système de communication entre nœuds et gère les services essentiels (par exemple, le gestionnaire de
paramètres et la gestion des nœuds).

bash

roscore

 Rqt

Un ensemble d'outils graphiques pour ROS, rqt permet de visualiser des topics, des services, de configurer
des paramètres et de déboguer des applications robotiques.
bash

ros2 run rqt_gui rqt_gui

 Rviz

Outil de visualisation 3D pour afficher des informations sur l'état du robot, comme les données de capteurs
(caméras, lidar, etc.) ou les trajectoires planifiées. C’est un outil très utilisé pour l'inspection et le
débogage.
bash

ros2 run rviz2 rviz2

 Gazebo

Simulateur de robot en 3D qui permet de tester des algorithmes et des comportements robotiques dans un
environnement virtuel avant de les déployer sur du matériel réel.
bash

ros2 launch gazebo_ros empty_world.[Link]

 Catkin (pour ROS1) / colcon (pour ROS2)

Catkin (ROS1) et colcon (ROS2) sont des outils de construction et de gestion de workspace (espace de
travail). Ces outils permettent de compiler et d'installer des paquets ROS.

bash

colcon build
source install/[Link]

10
  Rosdep

Outil de gestion des dépendances pour ROS. Il permet d'installer automatiquement les bibliothèques
nécessaires pour vos projets ROS.

bash

rosdep update
rosdep install --from-paths src --ignore-src -r -y

10. Installation de ROS2

Les étapes pour installer ROS2 Fox sur une distribution Ubuntu 20.04. Vous pouvez adapter selon votre
version d'Ubuntu ou d'autres systèmes (Windows, macOS).

a. Prérequis
1. Installer les outils nécessaires :

bash

sudo apt update

sudo apt install curl gnupg2 lsb-release

2. Ajouter la clé de dépôt de ROS2 :

bash

sudo curl -sSL [Link] | sudo tee

/etc/apt/[Link].d/[Link]

3. Ajouter le dépôt ROS2 à votre liste de sources :

bash

sudo sh -c 'echo "deb [arch=amd64] [Link] $(lsb_release

b. Installation de ROS2
1. Mettre à jour les dépôts :

bash

sudo apt update

2. Installer ROS2 (choisissez la version desktop pour les fonctionnalités complètes) :

bash

sudo apt install ros-foxy-desktop

11
 c. Configurer l'environnement ROS2
Ajouter la configuration à votre fichier. bashrc pour que ROS2 soit initialisé à chaque fois que vous
ouvrez un terminal :
bash

echo "source /opt/ros/foxy/[Link]" >> ~/.bashrc

source ~/.bashrc

Initialiser rosdep (outil pour gérer les dépendances) :

bash

sudo rosdep init

rosdep update
d. Vérifier l'installation

Pour vérifier si ROS2 a été correctement installé, vous pouvez exécuter la commande suivante pour voir
les nœuds et topics actifs :

bash

ros2 topic list

Vous pouvez également tester un exemple de nœud avec la commande :

bash

ros2 run demo_nodes_cpp talker

7. Conclusion

ROS est un puissant middleware pour la robotique qui vous permet de développer des applications
robotiques complexes tout en vous offrant une abstraction du matériel. Que vous soyez un chercheur, un
ingénieur en robotique ou un amateur, ROS vous offre un environnement flexible et robuste pour
développer, tester et déployer vos applications robotiques.

12
 II. Node-Red

1. Présentation du Node-Red
Node-RED, c'est comme une boîte à outils numérique qui permet de créer des applications simplement
en connectant des blocs appelés nœuds. Développé par IBM, cet outil open source offre une interface
intuitive où il suffit de glisser-déposer ces blocs pour créer des flux d'informations.

2. Fonctionnalités principales :
 Programmation par flux : Plutôt que d'écrire des lignes de code, on construit des chemins logiques
où chaque bloc représente une action (réception, traitement, ou envoi de données).
 Connectivité IoT : Node-RED excelle dans l'intégration d'appareils connectés, permettant de piloter
ou surveiller des systèmes physiques.
 Compatibilité large : Il prend en charge de nombreux protocoles comme MQTT, HTTP, ou
WebSocket et communique facilement avec des bases de données.
 Extensible : Des milliers de nœuds additionnels sont disponibles pour s’adapter à des besoins
spécifiques.
 Interface simple : Même sans grande expérience technique, on peut rapidement créer des flux grâce
à son système en glisser-déposer.

Node-RED fonctionne partout, des petits ordinateurs comme le Raspberry Pi aux serveurs en cloud, en
passant par les PC traditionnels.

3. Schéma fonctionnel de Node-RED

Un projet Node-RED repose sur ces éléments :

 Nœuds d'entrée : Ils récupèrent des données (capteurs, fichiers, API externes).
 Nœuds de traitement : Ils transforment ou analysent les données (filtres, conversions, calculs).

13
 Nœuds de sortie : Ils envoient les résultats vers des cibles comme une base de données, un écran ou
un appareil connecté.
 Nœuds de contrôle : Ils permettent de créer des logiques conditionnelles (boucles, déclencheurs).

 Tableau de bord interactif : Grâce à des graphiques et jauges, on peut visualiser et piloter les données
en temps réel.
Exemple :

Traitement des Commande

Capteur actionneur
données

(Arduino) (Node-Red) (ROS, MQTT)

3. Node-RED et ROS
 Échange de données : Avec des modules comme node-red-contrib-ros, Node-RED peut envoyer ou
recevoir des messages ROS.
 Visualisation et Contrôle : Node-RED offre des interfaces interactives pour surveiller les données
de ROS ou envoyer des commandes (par exemple, diriger un robot via le topic Twist).
 Automatisation : En reliant ROS à des outils IoT ou cloud via Node-RED, on peut automatiser les
décisions d'un robot.

Exemple concret : Node-RED reçoit des données de capteurs ROS, traite ces informations, et commande
le mouvement d’un robot en envoyant les instructions nécessaires.

4. Node-RED et Arduino : Le Contrôle Matériel

 Communication simplifiée : Node-RED peut échanger des données avec Arduino via USB,
Bluetooth ou même Wi-Fi.
 Pilotage des périphériques : On utilise Node-RED pour lire des valeurs de capteurs (température,
luminosité) ou activer des dispositifs (LED, moteurs).
 Tableaux de bord interactifs : Node-RED peut créer des panneaux de commande pour contrôler
Arduino en temps réel.

Exemple :

Arduino envoie la température ambiante à Node-RED.

Node-RED affiche la température dans un tableau de bord.

Si la température dépasse une limite, Node-RED allume un ventilateur via Arduino.

14
 4. Node-RED dans un Projet Robotique
En associant Node-RED, ROS et Arduino, on peut concevoir des systèmes robotiques flexibles et
puissants.

 Capteurs Arduino : Collecte des données (distance, température).

 Node-RED : Analyse et transmet les données à ROS.
 ROS : Prend des décisions (éviter un obstacle, naviguer).

 Node-RED Dashboard : Interface utilisateur pour surveiller le robot et interagir avec lui en
temps réel.

Exemple :

Imagine un robot autonome :

 Arduino mesure la distance à un obstacle.

 Node-RED récupère ces mesures, les affiche sur un tableau de bord, et les envoie à ROS.
 ROS décide d’arrêter ou de dévier le robot pour éviter la collision.
 L'utilisateur, via Node-RED, peut également envoyer des commandes manuelles.

5. Configuration Node-RED projet

15
 6. Conclusion
1. Node-RED simplifie l’intégration des systèmes complexes en robotique. Il permet de relier
facilement ROS, Arduino, et d’autres outils en utilisant une approche visuelle. Que ce soit pour
analyser des données, automatiser des flux, ou créer des interfaces de contrôle, Node-RED est un
maillon essentiel dans les projets robotiques modernes.

Grâce à sa flexibilité et sa simplicité, Node-RED devient le chef d'orchestre des systèmes Embarqués
intelligents.

III. Firebase

1. Définition
Firbose est une plateforme développée par Google pour faciliter le développement d'applications
mobiles et web. Elle propose une suite complète de services backend pour aider les développeurs à
créer, gérer et déployer des applications sans avoir à gérer l'infrastructure côté serveur et
utilise NoSQL pour héberger des bases de données.

2. Fonctionnalités principales de Firebase :

Base de données
 Firestore (Cloud Firestore) : Base de données NoSQL en temps réel avec synchronisation multi-
appareils.
 Realtime Database : Base de données NoSQL optimisée pour les données en temps réel
(synchronisation en direct) hébergée dans le cloud. Les données sont stockées au format JSON et
synchronisées en temps réel avec chaque client connecté, avec une prise en charge multiplateforme
pour iOS, Android, le Web, etc.

16
 Authentification

 Firebase Authentication permet d'authentifier les utilisateurs via email, téléphone, Google,
Facebook, ou d'autres services tiers (OAuth).

Hébergement

 Firebase Hosting offre un hébergement rapide et sécurisé pour les applications web et les fichiers
statiques (HTML, CSS, JavaScript).

Stockage

 Cloud Storage permet de stocker et de servir des fichiers (images, vidéos, etc.) via Google Cloud.

Fonctions Cloud

 Cloud Functions permet d'exécuter du code côté serveur en réponse à des événements déclenchés
par Firebase (ex. ajout de données, authentification, etc.).

Notifications et messagerie

 Firebase Cloud Messaging (FCM) permet d'envoyer des notifications push vers les appareils
iOS, Android ou des applications web.

Analyse

 Firebase Analytics offre des analyses détaillées sur l'utilisation de votre application et le
comportement des utilisateurs.

Tests et performances

 Firebase Performance Monitoring permet de suivre les performances de l'application en temps

réel.
 Firebase Test Lab aide à tester les applications sur une large gamme d'appareils physiques et
virtuels.

A/B Testing et personnalisation

 Firebase Remote Config permet de modifier les paramètres de l'application sans la redéployer.
 Firebase A/B Testing permet d'expérimenter et d'optimiser les fonctionnalités.

Avantages de Firebase :

 Rapidité : Accès facile à une suite complète de services backend pour démarrer rapidement.
 Scalabilité : Les services sont conçus pour gérer un grand nombre d'utilisateurs simultanément.
 Intégration facile : Compatible avec les plateformes iOS, Android et Web.

17
 Tarification flexible : Modèle "Pay-as-you-go" avec un niveau gratuit généreux.

3. Configuration du realtime database du projet :

18
IV. MIT App inventer

1. Définition
AppInventor est un logiciel développé par le MIT (le créateur de Scratch). Ce logiciel permet aux
débutants de créer des applications Android sans connaissance de codage. L'application transforme
l'assemblage de blocs graphiques en code Java pour un smartphone ou une tablette Android (comme pour
scratch). Ne fonctionne que pour Android. Ainsi, vous pourrez réaliser vos applications, mais aussi vos
objets connectés via une carte arduino, picaxe, LEGO NXT et maintenant le mBot par exemple.

AppInventor peut s'utiliser en ligne, c'est à dire que vous devrez vous connecter à votre compte Google
pour pouvoir l'utiliser, mais aussi en version logiciel portable sur votre ordinateur. Il existe 3 façons de
voir le rendu de votre application nouvellement créée, à l'aide de l'émulateur Android intégré, par Wi-fi
ou en connectant votre tablette ou smartphone Android via le port USB. Pour avoir un visuel en temps
réel des modifications apportées sur votre application, le mode wi-fi ou USB et donc à privilégier.

Il existe donc 3 mode pour gérer la vision de votre application sur votre tablette : par Wi-fi, par émulateur
intégré ou par USB.

Le plus simple étant par Wi-Fi, vous devez juste télécharger l'application AI2 Compagnon App sur votre
tablette (QR Code en bas de page). Vous pouvez également récupérer le fichier APK (fichier exécutable
sur Android) grâce au QR code.

Création d’application :

19
Cette interface d'application a été créée pour contrôler un robot et détecter des obstacles. Voici une
description de ses éléments :

1. Disposition et contrôle :

o L'écran est organisé en une disposition de type "croix directionnelle", avec des boutons
disposés autour d'un bouton central.

o Les boutons permettent de contrôler le mouvement du robot :

 F (Forward) : Avancer.

 B (Backward) : Reculer.

 L (Left) : Tourner à gauche.

 R (Right) : Tourner à droite.

 S (Stop) : Arrêter le robot (bouton central rouge).

2. Éléments d'interface :

o Deux étiquettes (Label1 et Label2) affichent l'état du robot, par exemple "status" ou des
messages spécifiques (comme la détection d'obstacles).

o Les boutons sont colorés (jaune pour les directions, rouge pour le bouton d'arrêt) pour une
meilleure visibilité.

3. Propriétés visuelles :

o L'arrière-plan de l'application est noir, ce qui rend les éléments plus visibles.

o L'alignement horizontal et vertical est centré pour une interface symétrique et intuitive.

20
Ce schémas représente la logique de programmation pour contrôler un robot via l'application, en utilisant
App Inventor. Voici une description détaillée des blocs visibles :

1. Contrôle des directions :

o Chaque bouton (gauche, droite, avant, arrière, stop) est relié à un bloc "when [Button]
Click".

o Lorsque l'utilisateur clique sur un bouton, une valeur spécifique est enregistrée dans la
base de données FirebaseDB1 avec le tag "data" :

 Left (Gauche) : Enregistre la valeur "2".

 Right (Droite) : Enregistre la valeur "3".

 Forward (Avant) : Enregistre la valeur "1".

 Backward (Arrière) : Enregistre la valeur "4".

 Stop : Enregistre la valeur "0".

2. Gestion des obstacles :

o Un bloc "when [Link]" surveille les modifications dans

FirebaseDB2.

o Si une nouvelle valeur est détectée sous un tag spécifique :

 Si la valeur indique un obstacle, Label1 affiche "Obstacle" et une action est

exécutée.

 Si aucune valeur ou obstacle n'est détecté, Label1 affiche "No Obstacle".

21
 3. Interactions avec Firebase :

o FirebaseDB1 est utilisé pour envoyer les commandes du robot en fonction des actions de
l'utilisateur.

o FirebaseDB2 est utilisé pour surveiller les retours d'information en temps réel, comme la
détection d'obstacles.

4. Organisation des blocs :

o Les blocs sont bien structurés pour répondre aux interactions utilisateur (contrôles) et aux
retours de l'environnement (détection d'obstacles).

Cette interface met en place un système bidirectionnel : l'utilisateur contrôle le robot, et l'application
reçoit des informations sur l'environnement (obstacles) via la base de données Firebase, rendant le
système interactif et réactif.

V. ARDUINO IDE

1. Présentation du logiciel
L’interface de l’IDE Arduino est plutôt simple, il offre une interface minimale et épurée pour

développer un programme sur les cartes Arduino. Il est doté d’un éditeur de code avec coloration

syntaxique et d’une barre d’outils rapide. Ce sont les deux éléments les plus importants de l’interface,

c’est ceux que l’on utilise le plus souvent. On retrouve aussi une barre de menus, plus classique qui est

utilisé pour accéder aux fonctions avancées de l’IDE.

Enfin, une console affichant les résultats de la compilation du code source, des opérations sur la carte,
etc.

22
 2. Structure d’un programme

1. La partie déclaration des variables (optionnelle) ;

2. La partie initialisation et configuration des entrées/sorties : la fonction setup () ;
3. La partie principale qui s'exécute en boucle : la fonction loop ().

Dans chaque partie d'un programme sont utilisées différentes instructions issues de la syntaxe du
langage Arduino.

23
 VI. Partie Materiel

1. Robot mobile

a) Châssis de robot avec roues et moteurs.

o Exemple : 4 roues motrices.

b) Moteurs DC

Un moteur à courant continu (DC) est un type de moteur électrique qui convertit l'énergie électrique (en
courant continu) en énergie mécanique. Il est couramment utilisé dans les applications de robotique pour
entraîner les roues ou d'autres éléments mobiles d'un robot.

Fonctionnement d’un moteur DC

Le moteur DC fonctionne grâce à l'interaction entre un champ magnétique généré par un aimant ou un
électroaimant et un courant électrique circulant dans l'enroulement du rotor. Cette interaction produit une
force de rotation, appelée couple.

Composants principaux d’un moteur DC :

24
 1. Rotor (ou armature) : Partie mobile qui tourne.
2. Stator : Partie fixe contenant l'aimant ou l'électroaimant.
3. Balais et collecteur : Assurent la commutation et la transmission du courant électrique au rotor.

Caractéristiques importantes d’un moteur DC pour un robot :

Tension nominale : Généralement 3V, 6V, 12V ou 24V.

Courant : Définit la consommation énergétique.

Couple : La force de rotation produite.

Vitesse de rotation (RPM) : Nombre de tours par minute.

Réduction d’engrenages (Gearbox) :

Permet d’augmenter le couple au détriment de la vitesse.

Idéal pour des applications nécessitant une force importante (comme déplacer un robot).

Contrôle des moteurs DC dans un robot

Pour contrôler un moteur DC dans un robot, on utilise souvent un module de contrôle des moteurs
comme le L298N ou le TB6612FNG.

Contrôle de base :

Direction : Changer la polarité du courant pour inverser le sens de rotation.

Vitesse : Utiliser un signal PWM pour ajuster la vitesse de rotation.

Exemple de connexion avec L298N :

ENA et ENB : Contrôlent la vitesse des moteurs avec un signal PWM.

IN1, IN2, IN3, IN4 : Définit la direction des moteurs.

VM et GND : Alimentation du moteur.

c) Contrôleur de moteur L298N

Le module L298N est un Double Pont-H destiné au contrôle de moteur (H-Bridge Motor Driver). Il est
basé sur le composant L298N. C'est un module extrêmement utile pour le contrôler de robots et
ensembles mécanisés. Il peut contrôler deux moteur courant continu ou un moteur pas-à-pas 4 fils 2
phases. Il est conçu pour supporter des tensions plus élevés, des courants importants tout en proposant
une commande logique TTL (basse tension, courant faibles, idéal donc pour un microcontrôleur).

25
 2. Carte microcontrôleur Arduino UNO
Arduino est la marque d'une plateforme de prototypage open-source qui permet aux utilisateurs de créer
des objets électroniques interactifs à partir :

 Cartes microcontrôleurs (matériel) : Utilisées pour lire des entrées (capteurs, boutons) et contrôler des
sorties (moteurs, LED).

 IDE Arduino (logiciel) : Un environnement de programmation basé sur C/C++ permettant d'écrire,
compiler et télé verser des programmes sur la carte.

Arduino Uno Processeur : ATmega328P

E/S numériques : 14 (dont 6 PWM)

E/S analogiques : 6

Mémoire Flash : 32 Ko

Caractéristiques : Idéale pour les débutants. Compatible avec la plupart des shields. Port USB standard.

3. Capteurs

Capteur à ultrasons (HC-SR04) pour détecter les obstacles.

Le capteur HC-SR04 utilise les ultrasons pour déterminer la distance d'un objet. Il offre une excellente
plage de détection sans contact, avec des mesures de haute précision et stables. Son fonctionnement n'est
pas influencé par la lumière du soleil ou des matériaux sombres, bien que des matériaux comme les
vêtements puissent être difficiles à détecter.
26
Caractéristiques

 Dimensions : 45 mm x 20 mm x 15 mm

 Plage de mesure : 2 cm à 400 cm  Résolution de la mesure : 0.3 cm

 Angle de mesure efficace : 15 °

 Largeur d'impulsion sur l'entrée de déclenchement : 10 µs (Trigger Input Pulse width)

Broches de connexion

 Vcc = Alimentation +5 V DC

 Trig = Entrée de déclenchement de la mesure (Trigger input)

 Echo = Sortie de mesure donnée en écho (Echo output)

 GND = Masse de l'alimentation

4. Module de communication

Module Bluetooth (HC-05 ou HC-06)

Module bluetooth HC-05 pour communication sans fil, vous pouvez le connecter avec la plateforme Arduino
en utilisant le port série pour envoyer et recevoir des informations.
 Doté d’un émetteur-récepteur radio de 2.4 GHz
 Protocole de communication : UART Bluetooth 2.0
 Conforme RoHS
 Le niveau du port du module est 3.3V.
 La tension d’entrée ne doit pas dépasser plus de 7V
 Prise en charge du débit en bauds standard 4800bps-1382bps.

27
 5. Source d'énergie

Batterie, des piles.

6. Divers

Breadboard, câbles Dupont, connecteurs.

Vis, tournevis, supports moteurs, etc.

7. Schéma électrique du robot

28
 Conclusion
Ce projet a permis de concevoir un robot mobile autonome et interactif, capable d’être piloté via une
application mobile et d'afficher des alertes en cas d'obstacles. L'utilisation combinée de ROS, Code-
RED et Arduino a facilité la gestion et la communication entre les différents modules du robot, rendant
son fonctionnement plus fluide et efficace.

Les principaux objectifs du projet ont été atteints :

- Contrôle manuel du robot via l’application mobile
-Affichage d’un message et d’une image en cas d’obstacle
-Intégration réussie de ROS pour la gestion des capteurs et des données
-Automatisation de certaines actions avec Code-RED

Malgré ces succès, plusieurs pistes d’amélioration peuvent être envisagées. L’ajout d’un mode de
navigation autonome avec évitement intelligent des obstacles, une meilleure gestion des ressources
processeur via ROS, ou encore une connexion Wi-Fi pour un contrôle à distance plus avancé pourraient
être des évolutions intéressantes.
En conclusion, ce projet constitue une base solide pour l’exploration de systèmes robotiques
intelligents, combinant capteurs, communication sans fil et automatisation. Il ouvre la voie à des
développements futurs dans les domaines de la robotique embarquée et des systèmes autonomes.

29
Annexe

Liens utiles et références

Documentation officielle de ROS2 :

[Link]

Forum ROS :
[Link]

GitHub de ROS :
[Link]

ROS Discourse (Communauté) :

[Link]

Simulateur Gazebo :
[Link]

Lien du MIT App inventer

[Link]

Reference
[Link]

Codes de projet
Code Arduino (Contrôle Robot)
#include <ros.h>
#include <std_msgs/Int32.h>

// Définition des broches pour les moteurs

int IN1 = 9; // Moteur 1, direction A
int IN2 = 10; // Moteur 1, direction B
int IN3 = 11; // Moteur 2, direction A
int IN4 = 12; // Moteur 2, direction B
int ENA = 2; // PWM pour le moteur 1
int ENB = 3; // PWM pour le moteur 2

// Définition des broches pour le capteur à ultrasons

int trigPin = 6;
int echoPin = 7;

// Variables globales

30
int startFlag = 0;
ros::NodeHandle nh;

// Fonction de rappel pour ROS

void callBackFunctionEtat(const std_msgs::Int32 &EtatROS) {
int state = [Link];

if (state == 2) {
Backward(); // Aller en arrière
startFlag = 1;
} else if (state == 3) {
turnLeft(); // Tourner à gauche
startFlag = 1;
} else if (state == 0) {
Forward(); // Aller en avant
startFlag = 1;
} else if (state == 4) {
turnRight(); // Tourner à droite
startFlag = 1;
} else if (statue == 1) {
stop(); // Arrêter
startFlag = 1;
}
}

std_msgs::Int32 CapteurROS;
ros::Publisher CapteurROSPublisher("Capteur", &CapteurROS);
ros::Subscriber<std_msgs::Int32> EtatROSsubscriber("Etat", &callBackFunctionEtat);

void setup() {
[Link]()->setBaud(9600);
[Link]();
[Link](EtatROSsubscriber);
[Link](CapteurROSPublisher);

// Initialisation des broches

pinMode(ENA, OUTPUT);
pinMode(ENB, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);

31
 pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
}

void loop() {
[Link]();
delay(5);

if (startFlag == 1) {
long duration, distance;

// Lecture du capteur à ultrasons

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH);

distance = (duration / 2) / 29.1;

// Publication de l'état du capteur

if (distance < 15) {
[Link] = 1; // Obstacle détecté
} else {
[Link] = 0; // Aucun obstacle
}
[Link](&CapteurROS);
}
}

// Fonctions de contrôle des moteurs

void Backward() {
// Moteur 1 recule (IN1 LOW, IN2 HIGH)
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);

32
 // Moteur 2 recule (IN3 LOW, IN4 HIGH)
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);

// Appliquer la vitesse aux moteurs

analogWrite(ENA, 200); // Augmentez la vitesse si nécessaire
analogWrite(ENB, 200);
}

void Forward() {
// Moteur 1 avance (IN1 HIGH, IN2 LOW)
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);

// Moteur 2 avance (IN3 HIGH, IN4 LOW)

digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);

// Appliquer la vitesse aux moteurs

analogWrite(ENA, 200); // Vitesse du moteur 1
analogWrite(ENB, 200); // Vitesse du moteur 2
}

void turnLeft() {
// Tourner à gauche : Moteur 1 recule, Moteur 2 avance
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
analogWrite(ENB, 200); // Appliquer une vitesse au moteur 2
}

void turnRight() {
// Tourner à droite : Moteur 1 avance, Moteur 2 recule
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
analogWrite(ENA, 200); // Appliquer une vitesse au moteur 1

33
}

void stop() {
// Arrêter tous les moteurs
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
}

Commandes pour la communication du Bluetooth et le démarrage du robot

34