0|Page

Table des matières

Table des matières ...................................................................................................................... 1
Liste des figures ......................................................................................................................... 2
Introduction ................................................................................................................................ 3
I. Application mobile .............................................................................................................. 4
1. MIT App Inventor : ......................................................................................................... 4
2. Création d'une application mobile de la commande du robot : ....................................... 5
II. Cloud .................................................................................................................................. 8
1. Firebase : ......................................................................................................................... 8
2. Firebase Realtime Database : .......................................................................................... 9
3. Configuration du Firebase :............................................................................................. 9
4. Configuration d'application mobile avec Firebase :...................................................... 10
5. Test de la communication App-Cloud : ........................................................................ 11
III. Communication Cloud-ROS........................................................................................... 12
1. Node-RED : .................................................................................................................. 12
1. Communication Cloud-Node RED : ............................................................................. 13
2. Communication Node RED-ROS : ............................................................................... 14
IV. Robot Operating System (ROS) ..................................................................................... 15
1. Description du ROS : .................................................................................................... 15
2. Configuration du ROS .................................................................................................. 15
V. Robot................................................................................................................................ 18
1. Matériel : ....................................................................................................................... 18
2. Construction : ................................................................................................................ 18
3. Principe de l’algorithme :.............................................................................................. 19
4. Code Arduino : .............................................................................................................. 19
4. Configuration ROS-Arduino :....................................................................................... 22
5. Test de système : ........................................................................................................... 22
Conclusion ................................................................................................................................ 24

1|Page
 Liste des figures
Figure 1 : Section Designer ........................................................................................................ 4
Figure 2 : Section Blocs ............................................................................................................. 5
Figure 3 : Interface d'utilisateur ................................................................................................. 5
Figure 4 : Composantes d’interface utilisateur .......................................................................... 6
Figure 5 : Code d’interface utilisateur ........................................................................................ 6
Figure 6 : Interface de commande .............................................................................................. 7
Figure 7 : Composantes d’interface de commande .................................................................... 7
Figure 8 : Code bouton ON ........................................................................................................ 8
Figure 9 : Code bouton OFF ...................................................................................................... 8
Figure 10 : Interface Realtime Database sur Firebase .............................................................. 10
Figure 11 : Code Firebase Token ............................................................................................. 11
Figure 12 : Configuration d'application mobile avec Firebase ................................................ 11
Figure 13 : Interface Node-RED .............................................................................................. 13
Figure 14 : Module Node-red-contrib-firebase ........................................................................ 13
Figure 15 : Configuration du module firebase.once() .............................................................. 14
Figure 16 : Module Snappy-ros ................................................................................................ 14
Figure 17 : Configuration du module ROS-publisher .............................................................. 14
Figure 18 : Flow de système .................................................................................................... 15
Figure 19 : Lancement de ROS sur le terminal ........................................................................ 16
Figure 20 : rostopic list 1.......................................................................................................... 16
Figure 21 : rostopic list 2.......................................................................................................... 16
Figure 22 : rostopic echo Our_Data 1 ...................................................................................... 17
Figure 23 : node Swich............................................................................................................. 17
Figure 24 : rostopic cho Our_Data 2 ........................................................................................ 17
Figure 25 : Schéma de montage ............................................................................................... 18
Figure 26 : Commande de la communication serial ................................................................. 22
Figure 27 : relier des topics ...................................................................................................... 22
Figure 28 : Réalisation pratique du système ........................................................................... 22
Figure 29 : rostopic echo Distance ........................................................................................... 23
Figure 30 : rostopic echo state.................................................................................................. 23

2|Page
 Introduction
ROS (Robot Operating System) est un système d'exploitation open source pour les
robots. Il fournit un ensemble d'outils et de bibliothèques pour aider à la construction, au
développement et à la maintenance de robots. ROS est particulièrement populaire dans la
communauté de la robotique de recherche et de développement, mais il est également utilisé
dans l'industrie et dans les applications grand public.

Le cloud Robotics, est une approche de la robotique qui utilise le cloud computing pour
fournir une puissance de calcul et un stockage supplémentaire pour les robots. Cela permet aux
robots de traiter des données en temps réel, d'accéder à des bases de données en ligne et de
communiquer avec d'autres robots et systèmes.

ROS et le cloud Robotics peuvent être utilisés conjointement pour améliorer les
capacités de traitement et de communication des robots. Par exemple, un robot utilisant ROS
peut utiliser le cloud computing pour accéder à des bases de données en ligne ou pour traiter
des données en temps réel, tout en utilisant les outils et les bibliothèques fournis par ROS pour
la construction et le développement de ses fonctionnalités. Cependant, il est important de
prendre en compte les préoccupations en matière de confidentialité et de sécurité liées à
l'utilisation du cloud computing pour la robotique.

Le but de ce mini-projet est de mettre en œuvre une application cloud Robotics à travers
le ROS.

3|Page
 I. Application mobile
1. MIT App Inventor :

App Inventor pour Android est un logiciel de développement

d'applications créé par Google, pour pallier la difficulté d'utilisation de Android
Studio par des débutants. Il est actuellement entretenu par le Massachusetts
Institute of Technology (MIT).

Il simplifie le développement des applications sous Android et le rend accessible même

pour les novices et ceux qui ne sont pas familiers avec les langages de programmation. Il est
basé sur une interface graphique similaire à Scratch et à celle de StarLogo TNG. Grâce à son
interface entièrement graphique et à l'absence totale de ligne de code, il est particulièrement
adapté à l'initiation des débutants à la programmation. Par la suite nous avons présenté
l’interface de cette application

Figure 1 : Section Designer

La section Designer donne la possibilité d'ajouter des boutons, d'ajouter du texte,

d'ajouter des écrans et de modifier l'apparence générale de l'application.

1. (Palette) : contient les composants pour construire la conception de l'application

comme les boutons, les curseurs, les images, les étiquettes, etc...
2. (Viewer) : contient les composants pour créer l'apparence de l'application.
3. (Components) : permet de voir tous les composants ajoutés sur application et
comment ils sont organisés hiérarchiquement.
4. (Properties) : C'est ici que vous sélectionnez les propriétés de vos composants
comme la couleur, la taille et l'orientation.

4|Page
 Figure 2 : Section Blocs

La section Blocs permet de créer des fonctionnalités personnalisées pour l’application.

Ainsi, lorsque on appuie sur les boutons, il fait réellement quelque chose avec cet événement.

1. (Blocks) : contient les blocs intégrés pour créer la logique de l'application. C'est ce
qui fait que l'application définit les fonctionnalités des boutons, envoie des
commandes à Arduino, se connecte au module Bluetooth, etc.
2. (Viewer) : contient blocs et les joignez d'une manière spécifique pour que quelque
chose se produise.
3. (sac à dos) : permet d’enregistrer des blocs de code à utiliser plus tard.
4. (poubelle) : pour les supprimer.
2. Création d'une application mobile de la commande du robot :

Afin de commander notre robot à distance, nous avons créé une application mobile qui
est composé de deux Interfaces :

a. Interface d'utilisateur :

Figure 3 : Interface d'utilisateur

5|Page
 Cette interface désigne l’ensemble des éléments graphiques et textuels qui permettent
une interaction entre l’utilisateur et l’application mobile. Elle a pour rôle de limiter l'utilisation
d'application et l'accès aux informations à des utilisateurs prédéfinies.

Les composantes de cette interface sont les suivants :

Figure 4 : Composantes d’interface utilisateur

Le programme de ce menu s’écrite comme suit :

Figure 5 : Code d’interface utilisateur

D’ailleurs nous avons initialiser le nom d'utilisateur sous le nom de « med » et le mot de
passe « 1111 ».

6|Page
 b. Interface de commande :

Figure 6 : Interface de commande

A travers cette interface, l'utilisateur peut allumer et éteindre le fonctionnement du robot

par les deux boutons ON et OFF.

Les composantes de cette interface sont comme suit :

Figure 7 : Composantes d’interface de commande

Le programme de ce menu s’écrite comme suit :

▪ Pour le bouton « ON » :

Si nous appuyons sur la touche ON, un message Boolean « false » sera envoyé à notre
cloud (dans notre cas c'est Firebase), sur un topic « data ».

7|Page
 Figure 8 : Code bouton ON

▪ Pour le bouton « OFF » :

Si nous appuyons sur la touche OFF, un message Boolean « true » sera envoyé à notre
cloud, sur le même topic « data ».

Figure 9 : Code bouton OFF

La configuration de notre application mobile avec Firebase sera expliquée dans la

section suivante.

II. Cloud
1. Firebase :

Firebase est le nom d’une plateforme mobile de Google qui facilite la création de back-
end à la fois scalable et performant. En d’autres termes, il s’agit d’une plateforme qui permet
de développer rapidement des applications pour mobile et pour le web.

L’objectif de la création de Firebase.google.com en 2011 par James Tamplin et Andrew

8|Page
Lee est d’éviter aux professionnels et aux particuliers de s’engager dans un processus complexe
de création et de maintenance d’une architecture serveur.

De plus, la plateforme peut être exploitée par plusieurs utilisateurs en même temps sans
connaître un quelconque bug. La praticité est également au rendez-vous grâce à ses
fonctionnalités intuitives. Depuis le rachat de la plateforme par Google en 2014, Firebase sdks
a connu de nombreuses améliorations et n’a de cesse de satisfaire ses utilisateurs.

2. Firebase Realtime Database :

Firebase Realtime Database n’est autre qu’une base de données NoSQL, bénéficiant
d’un hébergement « Cloud » et permettant le stockage et la synchronisation de données de vos
utilisateurs. Les développeurs peuvent gérer cette base de données en temps réel.

Firebase Realtime Database est capable de fournir à votre application la valeur des
données et les mises à jour appliquées sur ces dernières avec à une simple API. Grâce à la
synchronisation en temps réel, les utilisateurs de votre application peuvent consulter leurs
données depuis n’importe quel terminal (sur le web ou depuis leur mobile). Notez que cette
base de données est livrée avec des SDK mobiles et web et permet la création d’amplifications
sans utiliser de serveurs.

Quand vos utilisateurs passent en mode hors ligne, les SDK de base de données en temps
réel utilisent le cache pour enregistrer les modifications. Quand l’appareil est en ligne, les
données locales connaissent une synchronisation automatique. Dernière chose, Firebase
Database peut rejoindre l’authentification Firebase pour un processus d’authentification plus
simple et plus rapide.

3. Configuration du Firebase :

Après la création d'un compte gratuit sur le site officiel du Firebase. Nous cliquons sur
« Add Project » puis nous donnons un nom valable de projet, puis nous appuyons sur « Creat
Project » pour créer notre projet.

Nous cliquons sur « Build » et nous choisirons « Realtime Database ». Enfin, pour
terminer la configuration nous choisirons Locked mode.

Nous obtenons l’interface suivante :

9|Page
 Figure 10 : Interface Realtime Database sur Firebase

Nous cliquons sur « Rules », puis nous modifions « false » par « true » pour permet la
lire et la lecture via Firebase.

4. Configuration d'application mobile avec Firebase :

c « FirebaseURL » qui existe dans les propriétés de Firebase sur MIT App Inventor.

De plus nous cliquons sur « paramètre » → « Project settings » → « Service accounts »

→ « Database secrets », puis nous avons copié le champ « secret » et le collée sur le champ de
« Firebase Token » qui existe dans les propriétés de Firebase sur MIT App Inventor.

10 | P a g e
 Figure 11 : Code Firebase Token

Figure 12 : Configuration d'application mobile avec Firebase

5. Test de la communication App-Cloud :

Après avoir construit notre application, nous avons la télécharger sous la forme APK, et
nous avons l'installer sur un smartphone.

Nous ouvrons l'application, puis sur l'interface utilisateur nous saisissons le nom
d'utilisateur et le mot de passe comme mentionner précédemment.

Sur l'interface de la commande, si nous appuyons sur la touche « ON », un message

11 | P a g e
« data : false » s'affiche sur Firebase, et inversement si nous appuyons sur la touche « OFF » un
message « data : true » s'affiche sur Firebase.

Nous pouvons constater que la communication App-cloud marche bien.

III. Communication Cloud-ROS

1. Node-RED :

Node-RED est un environnement de

programmation low-code pour les applications
événementielles. Il utilise une méthode de
programmation graphique basée sur les flux. Ainsi,
l'utilisateur via des blocs de code prédéfinis appelés
"node" ou "nœud" en français constitue son programme en reliant les différents nœuds. Node-
RED a été développé en Javascript et est basé sur NodeJS.

Avec Node-RED, l'utilisateur n'a pas vraiment besoin d'avoir des connaissances pointues
en programmation, l'ensemble de sa conception de programme s'effectue en reliant et en
paramétrant des blocs de code.

▪ Node-RED a plusieurs avantages parmi lesquels on peut citer :

▪ Il réduit le temps nécessaire pour créer une application fonctionnelle.
▪ Il est accessible à un large éventail de développeurs et de non-développeurs.
▪ La nature visuelle de l'interface le rend très intuitif
▪ Il dispose d'une forte communauté et par conséquent il existe une panoplie de
bibliothèques Node-RED.

12 | P a g e
 Figure 13 : Interface Node-RED

1. Communication Cloud-Node RED :

Node-RED va jouer le rôle d'intermédiaire entre le Cloud et le ROS. Dans cette section
nous avons créé un node sur Node-RED qui effectue la communication entre le Cloud et Node-
RED.

Après avoir installé node-RED sur notre machine virtuel. Nous installons le
module « Node-red-contrib-firebase » pour la communication entre le Cloud et Node-RED.

Figure 14 : Module Node-red-contrib-firebase

Nous ajoutons le module « firebase.once() », ce module est responsable à lire les

données de Firebase. Nous le configurons comme suite :

Nous avons collé l’URL de référence sur le champ « Firebase », ainsi que le nom de
notre chemin sur le champ « Child Path ».

13 | P a g e
 Figure 15 : Configuration du module firebase.once()

2. Communication Node RED-ROS :

Dans cette section nous avons consacré à la communication entre Node-RED et ROS.

Nous installons le module « Snappy-ros » pour la communication entre Node-RED et ROS

Figure 16 : Module Snappy-ros

a. ROS-publisher :

Nous ajoutons le module « ROS-publisher », ce module est responsable à la publication

de notre topic sur ROS. Nous le configurons comme suite :

Nous saisissons le nom de notre topic, le type de paquet ainsi que le type des données
envoyer (dans notre cas c’est un booléen).

Figure 17 : Configuration du module ROS-publisher

14 | P a g e
 Nous lions le module « firebase.once() » avec « ROS-publisher » :

Figure 18 : Flow de système

IV. Robot Operating System (ROS)

1. Description du ROS :

Comme son nom l’indique, ROS (Robot Operating System) est un système
d’exploitation pour robots. De même que les systèmes d’exploitation pour PC, serveurs ou
appareils autonomes, ROS est un système d’exploitation complet pour la robotique de service.

Il est composé d’un ensemble de logiciels libres open source permettant de développer
des logiciels pour la robotique.

ROS est un méta système d’exploitation, quelque chose entre le système d’exploitation
et le middleware.

Il fournit des services proches d’un système d’exploitation :

▪ Abstraction du matériel
▪ Gestion de la concurrence
▪ Gestion des processus
ROS fournit aussi des fonctionnalités de haut niveau :

▪ Appels asynchrones
▪ Appels synchrones
▪ Base de données centralisée de données
▪ Système de paramétrage du robot
2. Configuration du ROS :

Nous lançons ROS sur un terminal par la commande :

$roscore

15 | P a g e
 Figure 19 : Lancement de ROS sur le terminal

Nous saisissons la commande $rostopic list sur nouveau terminal.

Figure 20 : rostopic list 1

Nous ouvrons notre application mobile, puis nous appuyons sur le bouton « ON ». Nous
consultant de nouveau la liste des topics.

Figure 21 : rostopic list 2

Nous constatons que le topic « Our_Data » que nous avons créé sur Node-RED, a été
ajouté.

16 | P a g e
 Nous saisissons la commande $rostopic echo Our_Data pour lire les données reçues dans
notre topic, puis nous appuyons sur le bouton « ON » et « OFF » successivement.

Figure 22 : rostopic echo Our_Data 1

Nous remarquons que le topic « Our_Data » publie toujours l'état « TRUE ».

Pour résoudre ce problème, nous ajoutons un node « SWITCH » sur Node-RED, puis
nous réessayons.

Figure 23 : node Swich

Figure 24 : rostopic cho Our_Data 2

Les deux états « True » et « False » ont été publiées avec succès.

17 | P a g e
 V. Robot
L'objectif de cette partie est de créer un robot
détecteur de présence qui se déplace dans une pièce
et évite les obstacles lorsqu'il en rencontre. Les
“yeux” du robot sont un capteur à ultrasons (par
exemple HC-SR04). Ce capteur est connecté à une
carte Arduino. Lorsque le capteur envoie
l'information à l'Arduino qu'il y a un obstacle devant
lui, l'Arduino doit envoyer une instruction aux
moteurs qui contrôlent les roues pour éviter l'obstacle.

1. Matériel :

Le matériel nécessaire est :

• Un Arduino Uno ou similaire.

• Un ou plusieurs capteurs à ultrasons HC-SR04.
• Des moteurs DC pour piloter les roues du robot.
• Un driver de moteurs DC (par exemple, L298 Mini)
• Un petit servo-moteur pour faire pivoter le capteur à ultrasons (la tête du robot)
• Une pile de 9V et des connecteurs pour alimenter les moteurs DC.
• Une Breadboard
• Des LEGO Technic ou du carton rigide pour construire le châssis du robot.
2. Construction :

Le schéma de montage sera comme suit

Figure 25 : Schéma du montage

18 | P a g e
 3. Principe de l’algorithme :

L'idée est d'utiliser une carte Arduino pour lire les données reçues par un capteur à
ultrasons. Lorsque nous appuyons sur le bouton ON sur notre application mobile, le robot
s'allume, et le capteur commence à détecter les obstacles devant lui, l'Arduino doit envoyer des
instructions aux moteurs qui pilotent les roues du robot pour l'éviter, ainsi qu’il doit envoyer le
type de mouvement du robot, et la distance mesurable par l'ultrasons vers le ROS. Le robot
s'arrête lorsqu'on appuie sur la touche OFF sur l’application.

4. Code Arduino :

Par la suite nous avons présenté quelques captures du code Arduino :

Dans le cadre de chaque programme ROS Arduino, nous devons inclure le fichier d’en-
tête ros.h et les fichiers d'en-tête pour tous les messages que nous utiliserons, ici nous utilisons
un message standard Boolean, int16 et String.

Nous devons instancier le nœud handle ; node handle permet à notre programme de créer
des Subscriber et des Publisher. Il prend également en charge les communications du port série.
« nh » est juste le nom que nous avons donné à ce NodeHandle.

« std_msgs » contient des wrappers pour les types de messages ROS. Dans notre cas, il
s'agit d’un nombre entier et d’une chaîne de caractères.

« USDinstance » et « OurLedState » sont successivement le nom de notre variables

entier, et de chaine de caractères.

Lorsque nous voulons savoir le mouvement de notre robot ainsi que la distance entre le
robot et un obstacle, nous appellerons sur deux terminales les deux topics « Distance » et
« state ».

19 | P a g e
 La fonction « PauseIfRequested() » est responsable sur le mouvement, et l'arret du
robot.

Dans la fonction de boucle Arduino, ros::spinOnce() gérera la transmission des

messages vers le Publisher. ROS ne traite nos rappels que lorsque nous le lui dites avec
spinOnce().

Nous créons la fonction de rappel pour notre Subscriber. La fonction de rappel doit
prendre une référence constante d'un message comme argument.

Dans notre rappel fonction nommé « messageCb », le type de message est

std_msgs::Bool et le nom du message sera « msg ».

À l'intérieur du fonction « messageCb » nous initialisons le mode de fonctionnement

(mouvement et arrêt) de notre robot.

Nous appellerons le topic dans le Terminal en appelant des arguments entre parenthèses.
Dans notre cas, lorsque nous voulons faire allumer et éteindre notre robot, nous appellerons
« MoveStopRobot ».

Dans la fonction de configuration d'Arduino, nous devons ensuite initialiser notre handle
de nœud ROS (nommé « nh »), annoncer tous les topics en cours de « publisher » et abonner à
tous les topics que nous souhaitons « subscribe ».

20 | P a g e
 Les arguments entre parenthèses sont les noms des parties auxquelles le « subscribe »
ou « publisher » fait référence.

La fonction Loop décrit le fonctionnement de notre système.

« PauseIfRequested () » permet d’arrêter le fonctionnement du robot si le topic « msg »

a une état « False », et vice versa.

« USFonction » permet de publier la distance mesurer pas l’ultrasons.

Nous trouvons sur chaque fonction de la commande des moteurs la fonction « LEDstate
» qui permet de publier le type de mouvement du robot.

21 | P a g e
 4. Configuration ROS-Arduino :

Nous retournons au ROS, après la transmission de code vers l'Arduino.

Nous saisissons cette commande sur le terminal qui permet la communication serial
d’IDE Arduino avec notre robot :

$rosrun rosserial python serial_node.py /dev/ttyACM0

Figure 26 : Commande de la communication serial

Sur un nouveau terminal nous saisissons cette commande qui permet de relier le topic
« Our_Data » créé par Node-RED avec le topic « MoveStopRobot » créé par IDE Arduino.

$rosrun topic_tools relay Our_Data MoveStopRobot

Figure 27 : relier des topics

5. Test de système :

Nous appuyons sur le bouton « ON » pour exécuter notre robot.

Figure 28 : Réalisation pratique du système

22 | P a g e
 Nous saisissons la commande suivante pour lire la valeur de la distance entre le robot et
un obstacle.

$rostopic echo Distance

Figure 29 : rostopic echo Distance

Nous saisissons la commande suivante pour lire le type de mouvement du robot.

$rostopic echo state

Figure 30 : rostopic echo state

23 | P a g e
 Conclusion

Nous avons montré comment, avec très peu de codage, nous pouvons avoir un système
complexe de variables que nous pouvons manipuler à notre guise, ceci été réaliser à travers le
ROS. Cependant, il est important de noter que ROS nécessite une certaine expérience en
programmation et en robotique pour être pleinement utilisé. De plus, comme il s'agit d'un
système d'exploitation open source, il peut y avoir une certaine incertitude quant à la qualité et
à la stabilité des différentes bibliothèques et outils disponibles. En général, ROS est un outil
utile pour les développeurs de robots, mais il est important de peser les avantages et les
inconvénients de son utilisation dans chaque projet de robotique spécifique.

24 | P a g e