Mon Premier Objet Connecté Découvrir Les Réseaux Informatiques

Julien Launay
MON PREMIER
OBJET
CONNECTÉ
Découvrir les réseaux
informatiques

Aujourd’hui, notre environnement est devenu hyperconnecté. Les systèmes Titulaire d’un DESS en automatique et infor-
qui nous entourent, de notre lave-linge aux transports en commun, partagent matique industrielle, Julien Launay est pro-
des données pour améliorer notre quotidien. Le monde de l’Internet des fesseur de technologie au collège et au lycée
objets (Internet of Things en anglais ou IoT) est en marche ! Mais comment depuis 25 ans. Il enseigne également en IUT
fonctionnent ces objets connectés? Comment partagent-ils des informa- Informatique, ainsi qu’en école d’ingénieur.
tions? Quels réseaux exploitent-ils? Il est aussi l’auteur de l’ouvrage Les réseaux
informatiques par la pratique, paru aux édi-
Avec juste quelques connaissances de base en programmation, cet ouvrage tions Eyrolles.
très illustré vous initiera au monde de l’IoT à travers la réalisation de plu-
sieurs objets connectés (une lampe, un thermomètre, un robot). Pour
cela, vous utiliserez la carte à microcontrôleur Galaxia, simple d’emploi et
de faible coût, que vous programmerez dans un environnement visuel par
blocs de type Scratch. Vous connecterez ainsi ces objets à un réseau TCP/
IP, puis vous créerez une page web affichant les données des capteurs. Vous
serez également amené à concevoir votre propre réseau, ce qui vous per-
mettra de vous familiariser avec les différentes notions associées (protocole,
adresse IP, etc.). Avec ce livre ludique, vous apprendrez par la pratique !

Aux enseignants et élèves de collèges/lycées
Aux associations, clubs d’électronique, bibliothèques…

Qu’est-ce qu’un objet connecté ? • Pourquoi un monde connecté ? • Composition
d’un système pour l’IoT • Réseaux utilisés pour l’IoT • Créer son propre réseau
IoT • Programmer la carte Galaxia • Présentation de Galaxia • Interface
de développement • Programmation • Ressources en vidéo • Interface de
développement Vittascience • Lampe connectée • Créer un réseau • Identifier les
éléments du réseau • Vérifier le réseau • Mettre en œuvre la lampe connectée •
Thermomètre connecté • Analyser le système • Tester le capteur IoT • Mettre le
capteur en réseau • Programmer le capteur • Tester le capteur • Adresse IP du
système connecté • IoT sur une page web • Notion de client-serveur sur un réseau
• Fonctionnement d’une page web • Programmer une page web sur la carte Galaxia
• Commander la carte Galaxia avec une URL • Échanger des données avec la carte
Galaxia • Application à construire • Dessiner l’application • Programmer la carte
Galaxia • Tester le système • Utiliser une plate-forme IoT et le protocole MQTT •
Protocole MQTT • Plate-forme HiveMQ • Plate-forme Adafruit • Commander un
robot • Présentation du robot Maqueen • Piloter un robot avec une application
Dashboard • Pour aller plus loin
MON PREMIER
OBJET
CONNECTÉ
CHEZ LE MÊME ÉDITEUR
Dans la collection « Serial Makers »
J. LAUNAY. – Les réseaux informatiques par la pratique.

N° 67984, 2020, 136 pages.
J. LAUNAY. – Créer des applis avec App Inventor.

N° 67901, 2020, 120 pages.
J. LAUNAY. – Python pour la carte micro:bit.

N° 67826, 2019, 168 pages.
E. BARTMANN. – Le grand livre d’Arduino (4e édition).

N° 0100583, 2022, 544 pages.
J. BOYER. – Réparer son électroménager et ses autres appareils électriques.

N° 0100460, 2022, 432 pages.
R. SARAFAN. – Robots DIY.

N° 0100473, 2021, 192 pages.
D. NIBART. – 46 activités avec le mBot2.

N° 0100628, 2022, 96 pages.
D. NIBART. – 45 activités avec le mBot.

N° 0100270, 2021, 88 pages.
D. NIBART. – 30 défis robotiques.

N° 0100119, 2021, 64 pages.
D. NIBART. – 50 activités avec la carte micro:bit.

N° 0100296, 2021, 80 pages.
J.-B. BOICHAT. – Programmer en Java pour le Raspberry Pi 3.

N° 67746, 2019, 348 pages.
J.-M. MOLENAAR et M. SABOURDY. – Les machines à commande numérique.

N° 14172, 2018, 176 pages.
J. BOYER. – Réparez vos appareils électroniques (2e édition).

N° 67621, 2019, 404 pages.
C. PLATT. – L’électronique en pratique (2e édition).

N° 14425, 2016, 328 pages.
M. BERCHON. – Le grand livre de l’impression 3D.

N° 67770, 2020, 280 pages.
C. BOSQUE, O. NOOR et L. RICARD. – FabLabs, etc. Les nouveaux lieux de fabrication numérique.
N° 13938, 2015, 216 pages.
Julien Launay
MON PREMIER
OBJET
CONNECTÉ
Découvrir les réseaux
informatiques
Éditions Eyrolles
61, bd Saint-Germain
75240 Paris Cedex 05
www.editions-eyrolles.com
En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le présent ouvrage, sur quelque support
que ce soit, sans l’autorisation de l’Éditeur ou du Centre français d’exploitation du droit de copie, 20, rue des Grands-Augustins, 75006 Paris.
© Éditions Eyrolles, 2022

ISBN : 978-2-416-00822-1
Remerciements
Je tiens à remercier tout particulièrement l’équipe des éditions Eyrolles et Antoine Derouin pour avoir
accepté l’ouvrage proposé et m’avoir permis d’écrire en toute liberté. Merci aussi pour cette relecture très
minutieuse et ô combien indispensable.
Merci à André Bernot, de la société A4, pour son aide matérielle autour de la carte ESP32, ainsi que ses
capteurs et actionneurs Grove, son robot CODO et Maqueen.
Un grand merci tout particulier à Cyril de Thingz, avec qui j’ai échangé autour de sa carte Galaxia et qui a
su s’adapter rapidement à mes demandes.
Merci aussi à Léo, de Vittascience, qui adapte son environnement à la carte Galaxia.
Un merci tout particulier à ma petite famille, qui a pu supporter mes périodes de travail limitant mes dispo-
nibilités et qui m’a soutenu dans cet exercice.
5
Avant-propos
Notre environnement devient de plus en plus connecté. Les systèmes qui nous entourent, de notre lave-
linge aux transports en commun, partagent des données pour améliorer notre quotidien. Depuis l’arrivée
du smartphone en 2007, ces connexions se démultiplient et les nouveaux services toujours plus nombreux.
Et nous n’en sommes qu’au début…
Si l’IoT (Internet of Things) évolue, c’est grâce à différents facteurs :

• un maillage des réseaux de plus en plus dense et disponible presque partout, transportant de plus en plus
de données ;
• des plates-formes de stockage des données ;
• une électronique de plus en plus performante et miniaturisée ;
• des systèmes de stockage d’énergie et des coûts compatibles avec une distribution massive.
Le nombre de ces données maintenant disponibles explose. Pour les traiter, les bases de données classiques
cèdent la place à des outils d’intelligence artificielle associés à des algorithmes de traitement automatique.
Vous allez découvrir dans cet ouvrage comment créer un objet connecté fonctionnel afin de mieux
comprendre ce monde de l’IoT. Vous utiliserez la carte Galaxia à base de microcontrôleur, qui facilitera la
réalisation des objets connectés. Cette carte présente, outre son faible coût, l’avantage d’être compacte et
très facile à utiliser avec un outil de développement simple et performant.
Cet ouvrage s’adresse à des débutants en informatique. Il suffira de connaître quelques bases simples de
programmation, vues avec Scratch au collège par exemple. Cette programmation sera réalisée en mode
blocs pour simplifier le propos. Vous utiliserez le réseau déjà installé chez vous pour tester vos solutions IoT.
Il ne s’agit ici que d’une initiation. Il existe bien sûr d’autres systèmes plus performants, mais moins acces-
sibles économiquement et dont le niveau de complexité requiert des compétences supérieures.
Dans ce livre, vous allez ainsi vous familiariser avec les réseaux informatiques par la pratique, en créant
votre propre réseau et en l’utilisant. Vous pourrez alors plus facilement appréhender le vocabulaire associé,
la notion de protocole, d’adresse IP, etc…
Cet ouvrage vous permettra donc de vous faire votre propre avis sur l’utilisation de l’IoT au quotidien.
Les objets connectés sont capables de prendre des décisions de façon autonome, sans l’intervention de
l’être humain. Vous pourrez ainsi réfléchir aux questions suivantes :
• Est-ce que l’IoT aura un impact environnemental ?
• Quel sera le contrôle de l’être humain sur la machine ?
• Devons-nous confier nos données personnelles à des machines ?
• Est-ce que les machines prendront des décisions importantes à notre place ?
• Quelle sera la responsabilité des algorithmes ?
• Quel niveau de confiance accorder à ces derniers ?
• Est-ce que l’intelligence artificielle et l’IoT permettront de trouver de nouvelles lois physiques ?
7
MON PREMIER OBJET CONNECTÉ
• Si les objets connectés et leurs données sont restreints par le périmètre de leurs usages, est-ce que l’IoT
permettra une réelle autonomie ?
Si vous souhaitez aller plus loin, n’hésitez pas à lire Les réseaux informatiques par la pratique pour en apprendre
davantage sur les réseaux et Créer des applications avec App inventor pour programmer des applis sur smart-
phone ; ces deux ouvrages sont disponibles aux éditions Eyrolles.
Alors maintenant, lancez-vous dans ce monde des objets connectés. Bonnes expériences !
8
Table des matières
1 Qu’est-ce qu’un objet connecté ?.............................................................................. 11

Pourquoi un monde connecté ?......................................................................................................................... 11
Composition d’un système pour l’IoT................................................................................................................ 11
Réseaux utilisés par l’IoT.................................................................................................................................. 12
Créer son propre réseau IoT............................................................................................................................. 13
2 Programmer la carte Galaxia..................................................................................... 17

Présentation de Galaxia.................................................................................................................................... 17
Interface de développement............................................................................................................................. 18
Programmation.................................................................................................................................................. 19
Ressources en vidéo.......................................................................................................................................... 22
Interface de développement Vittascience........................................................................................................ 22
3 Lampe connectée....................................................................................................... 23
Créer un réseau................................................................................................................................................. 23
Identifier les éléments du réseau..................................................................................................................... 24
Vérifier le réseau............................................................................................................................................... 26
Mettre en œuvre la lampe connectée............................................................................................................... 27
4 Thermomètre connecté.............................................................................................. 29
Analyser le système........................................................................................................................................... 29
Tester le capteur............................................................................................................................................... 30
Mettre le capteur en réseau.............................................................................................................................. 31
Programmer le capteur..................................................................................................................................... 31
Tester le capteur IoT......................................................................................................................................... 33
Adresse IP du système connecté...................................................................................................................... 35
5 IoT sur une page web................................................................................................. 37

Notion de client/serveur sur un réseau............................................................................................................ 37
Fonctionnement d’une page web...................................................................................................................... 38
9
Programmer une page web sur la carte Galaxia.............................................................................................. 38

Commander la carte Galaxia avec une URL...................................................................................................... 42
6 Échanger des données avec la carte Galaxia............................................................ 45

Application à construire.................................................................................................................................... 45
Dessiner l’application........................................................................................................................................ 45
Programmer la carte Galaxia............................................................................................................................ 50
Tester le système............................................................................................................................................... 51
7 Utiliser une plate-forme IoT et le protocole MQTT.................................................... 53

Protocole MQTT.................................................................................................................................................. 53
Plate-forme HiveMQ........................................................................................................................................... 55
Plate-forme Adafruit.......................................................................................................................................... 63
8 Commander un robot.................................................................................................. 81
Présentation du robot Maqueen........................................................................................................................ 81
Piloter un robot avec une application Dashboard............................................................................................ 82
Pour aller plus loin............................................................................................................................................ 90
10
1 Qu’est-ce qu’un objet connecté ?
Le monde de l’Internet des objets (Internet of Things – IoT) met en relation le monde physique réel avec le
monde virtuel. Il fait dialoguer des machines entre elles. En général, une structure IoT met en œuvre un
objet associé à des capteurs et/ou des actionneurs, des passerelles qui conduisent les données jusqu’à des
serveurs, lesquels accueillent des plates-formes dédiées sur un cloud. Ces données seront ensuite visualisées
et traitées sur un ordinateur ou un smartphone connecté au cloud. On pourra ainsi connaître les places de
stationnement libres les plus proches de soi ou suivre l’état d’un patient à distance. C’est un domaine en
pleine évolution.
Pourquoi un monde connecté ?

Le monde de l’Internet des objets est en très forte croissance. Il est maintenant très facile de connecter
des objets de notre quotidien comme une automobile, un lave-linge, une cafetière, un compteur d’énergie
électrique Linky, un système de mesure de sa consommation d’eau, un système d’information sur l’état des
routes, etc. Les applications sont multiples dans le transport, la « ville intelligente », l’énergie et l’industrie.
En général, les objets connectés ne nécessitent aucune intervention humaine et sont autonomes.
L’IoT s’appuie sur :

• des capteurs de plus en plus nombreux, bon marché et intégrés ;
• une connectivité facilitée par différents réseaux ;
• des plates-formes d’hébergement des données collectées ;
• des systèmes d’analyse de plus en plus évolués, recourant en particulier à l’intelligence artificielle.
Composition d’un système pour l’IoT

Un système pour l’IoT est composé principalement de cinq parties (figure 1–1) :
• des capteurs et actionneurs ;
• un moyen de connexion, plutôt sans fil pour une plus grande souplesse d’utilisation et davantage
d’autonomie ;
• un réseau pour acheminer les données issues du système ;
• une plate-forme d’hébergement des données ou cloud, qui permettra à un client de récupérer les données ;
• un client pour analyser et traiter les données et les transformer en informations.
11
Capteur / Actionneur
Objet connecté
PC / smartphone
Passerelle Plate-forme IoT (cloud)
(applications)
Capteur / Actionneur
Objet connecté
Figure 1–1 – Organisation schématique de l’IoT.
Réseaux utilisés par l’IoT

Comme son nom l’indique, un objet connecté a besoin d’un réseau. Il existe différents supports de commu-
nication, principalement sans fil. Le système doit pouvoir se connecter le plus simplement possible à un
réseau disponible autour de lui.
Les réseaux présentés à la figure 1–2 sont principalement utilisés et ont chacun une portée, un débit et une
couverture caractéristiques.
Les réseaux LoRa et Sigfox sont les plus utilisés dans le monde de l’IoT. Leur portée est importante et
couplée à une faible consommation d’énergie, mais avec un débit faible de données.
70
64 %
60
50
40
30 29 %
25 %
22 %
20 20 %
10 9%
4%
2%
0
LoRa, Sigfox
Réseaux mobiles EnOcean
(2G, 3G, 4G, 5G)
Wi-Fi
Zigbee
Autres
Bluethooth low energie (BLE)
Réseau filaire
Figure 1–2 – Taux d’utilisation des différents supports de communication.
12
CHAPITRE 1. QU’EST-CE QU’UN OBJET CONNECTÉ ?
La figure 1–3 montre quel réseau choisir en fonction de sa portée et du débit de données souhaité.
Débit
100 MBps Wi-Fi
5G - 4G - 3G
Wi-Fi
Halow
1 MBps Bluetooth
BLE LTE-M
100 kBps NB-IoT
Zigbee
Z-Wave
1 MBps
LoRa
RFID
SigFox
0
1m 10 m 100 m 1 km 10 km Portée
Figure 1–3 – Répartition des réseaux selon leur portée et leur débit de données.
Pour des raisons de simplicité et de coût, nous utiliserons dans ce livre le réseau Wi-Fi, qui a l’avantage
d’être disponible facilement, avec une mise en œuvre simplifiée et des systèmes à très faible coût.
Créer son propre réseau IoT

Pour créer son propre réseau IoT, il existe différents systèmes disponibles sur le marché. Toutes les cartes
présentées dans cette section permettent de se connecter à un réseau. Il en existe bien d’autres.
IOTBIT de Elecfreaks
Cette carte permet de créer un objet connecté à l’aide d’une
carte micro:bit. La programmation est réalisée à l’aide de
l’IDE makecode.microbit.org en installant une extension
spécifique.
Le support de connexion utilisé est le Wi-Fi.
Il est nécessaire d’avoir une connexion à Internet. On ne peut

Elecfreaks
pas faire fonctionner ce système sur un réseau local seul.
Figure 1–4 – Carte IOTBIT.
Pour plus d’information
https://www.elecfreaks.com/learn-en/microbitKit/iot_kit/iot_bit.html
13
MiBot32 de Cartelectronic
Cartelectronic
Cartelectronic
Figure 1–5 – Carte MiBot32 connectée Figure 1–6 – Carte MiBot32 connectée au robot mBot.
à une carte micro:bit.
Cette carte permet de transformer une carte micro:bit ainsi que le robot mBot de chez Makeblock en objets
connectés.
https://www.cartelectronic.fr/29-robot-educatif
Il suffit ensuite d’utiliser l’IDE de programmation par blocs makecode.microbot.org pour la carte micro:bit
avec l’extension proposée ou mBlock 5 avec le robot mBot.
ESP32 DevkitC
Cette carte sert à créer des prototypes.
Figure 1–7 – Carte ESP32 DevkitC.
14
CHAPITRE 1. Qu’est-ce qu’un objet connecté ?
Cartes de type SIM 800

Ce type de carte communique avec un réseau
identique à celui de votre téléphone portable.
L’intérêt est de pouvoir utiliser ce système dans
Waveshare
des zones reculées.
Le support de connexion utilisé est un réseau 2G,

3G, 4G ou 5G.
Figure 1–8 – Carte de type SIM 800.
Galaxia de Thingz
Elle est très proche de la carte micro:bit, avec le gros avantage de proposer
une connexion Wi-Fi et un écran. Le connecteur est totalement compa-
tible avec celui de la micro:bit.
C’est cette carte que nous utiliserons dans cet ouvrage. Elle présente
l’avantage d’être très simple d’utilisation et très polyvalente. L’interface
de développement propose une programmation par blocs ou en Python
ou même en langage C.
Thingz
Nous présenterons une programmation de type blocs, qui permet une
initiation à l’IoT très progressive et sans difficultés.
Figure 1–9 – Carte Galaxia de Thingz.
15
2 Programmer la carte Galaxia
La carte Galaxia est l’un des différents systèmes permettant de créer un objet connecté. Vous allez découvrir
comment la programmer simplement avec des blocs, en vous inspirant de ce que l’on fait avec Scratch.
Présentation de Galaxia
La carte Galaxia de Thingz va vous permettre de programmer des objets connectés. Elle est basée sur un
microcontrôleur ESP32 qui intègre un grand nombre de fonctionnalités (figures 2–1 et 2–2).
Thingz
Figure 2–1 – Aspect de la carte Galaxia.
Connexions
vers connecteurs Boutons-poussoirs
Connexion son A et B
Connexions Prise USB vers

prises Grove PC + alim
Microcontrôleur avec
Capteur connexion Wi-Fi et BLE
lumière Pavé tactile
4 boutons
Accéléromètre Bouton
système Écran DEL couleur
Figure 2–2 – Éléments composant la carte Galaxia.
17
Interface de développement
Pour programmer la carte Galaxia, vous allez utiliser une interface de développement (Integrated Development
Environment – IDE) disponible en ligne sur le site https://play.thingz.co/galaxia (figure 2–3).
Figure 2–3 – Interface pour programmer la carte Galaxia.
À gauche sont proposés les blocs de programmation disponibles, classés par thèmes correspondant à diffé-
rentes couleurs. Au centre, votre programme sera un ensemble de blocs que vous glisserez-déplacerez depuis
le menu de gauche. En haut à gauche, deux boutons bleus servent respectivement à ouvrir et sauvegarder
votre programme. En haut à droite sont proposés des boutons pour se connecter à la carte et téléverser le
programme.
Il est possible de programmer la carte dans différents langages de programmation : programmation par blocs,
Python, C++. Dans cet ouvrage, nous nous limiterons au langage Blockly par simplicité. C’est ce même
langage qui est utilisé par Scratch par exemple. Les boutons orange en haut à gauche (Blockly, Hybride et
Python) servent à convertir les blocs en programme Python.
Les utilisateurs du navigateur Google ) devront d’abord installer l’extension thingz via ce lien :
https://chrome.google.com/webstore/detail/thingz/ifpbemhfgibeaednjoidchimcbphpacn?hl=fr
Puis cliquez sur Ajouter à chrome pour installer cette extension. Elle vous permettra de téléverser le
programme à l’aide d’un seul bouton, une fois la carte Galaxia connectée en USB à l’ordinateur.
Important
L’outil de développement proposé sur le site https://play.thingz.co/galaxia est susceptible d’évoluer dans le temps avec
de nouvelles fonctionnalités ou des modifications et adaptations. Pour vous permettre d’avoir une compatibilité constante et
adapté à ce livre, vous pourrez aussi utiliser le lien https://play.thingz.co/eyrolles. Vous y trouvez les mêmes commandes
que dans cet ouvrage.
18
CHAPITRE 2. Programmer la carte Galaxia
Programmation
Découvrons tout d’abord comment utiliser l’interface de développement pour programmer la carte Galaxia.
La méthode est assez classique.
1. Analysez votre cahier des charges.
2. Dessinez un diagramme de blocs internes pour identifier les différents éléments utilisés par la carte ainsi
que ses éventuels périphériques. Cela vous aidera à visualiser les flux de données.
3. Identifiez les différents événements associés à votre projet.
4. Pour chaque événement, rédigez un algorithme.
5. Codez chaque algorithme.
6. Téléversez le code dans la carte.
7. Déboguez et utilisez au besoin le mode pas à pas avec visualisation des variables.
8. Testez votre programme sur un jeu de tests.
Sur certains IDE, on peut lancer un simulateur de la cible.
Premier programme Z
y
Pour vous familiariser avec l’environnement de développement, créons un
programme qui va détecter un mouvement vertical de votre carte Galaxia.
Pour cela, vous allez recourir au capteur d’accélération qui est intégré
x
à la carte. Ce capteur mesure trois accélérations suivant trois axes x, y
et z (figure 2–4).
Dans notre cas, le soulèvement modifiera l’accélération suivant l’axe

vertical z. Rappelons que l’accélération est la variation de vitesse.
Tester l’accéléromètre
Dans un premier temps, vous allez simplement afficher la valeur du
Figure 2–4 – Capteur intégré
capteur pour visualiser son fonctionnement.
de la carte Galaxia.
Voici l’algorithme et sa traduction en blocs (figure 2–5) :
DEBUT
TANT QUE vrai
Afficher accélération sur l’axe vertical z
Attendre 200 ms
FIN TANT QUE
FIN
Figure 2–5 – Programme pour visualiser

l’accélération verticale.
19
Pour téléverser le programme dans la carte Galaxia,

connectez cette dernière à votre ordinateur avec le
câble USB (figure 2–6).
Vérifiez que le bouton Connecté à la carte est bien vert

(figure 2–7). S’il est rouge, cela signifie que la connexion
n’est pas établie. Cliquez ensuite sur le bouton Téléverser.
Votre programme est alors transféré sur la carte et s’exé-

cute. Positionnez votre carte à l’horizontale sur une table.
Visualisez les valeurs affichées. Vous constatez qu’elles
varient très peu autour de 1 024. Cette valeur correspond Figure 2–6 – Connexion de la carte Galaxia à l’ordinateur.
à la mesure de l’accélération initialement en m/s . -2
On voit bien que l’axe z correspond à la verticale.

Il serait possible d’utiliser les autres axes pour
détecter d’autres directions de mouvements. En fait,
vous mesurez ainsi le champ de gravité terrestre, Figure 2–7 – Connexion établie ; prêt à téléverser.
qui est bien de 1 m/s² ou 1 g en statique horizon-
talement et qui correspond à une valeur numérique
approchée de 1 024.
Détecter un mouvement vertical

Si l’accéléromètre de la carte indique une valeur différente de 1 024 environ, alors on aura détecté un
mouvement vertical. Cela pourrait être un soulèvement de la carte.
L’algorithme associé à l’événement « démarrage de la carte » est le suivant :
DEBUT :
Effacer l’écran
Afficher « Détection d’un soulèvement »
RÉPÉTER toujours
accélération ← valeur du capteur d’accélération axe z
SI accélération>1076 OU accélération<976 ALORS
Afficher « Objet soulevé ! »
Attendre 3 s
FIN SI
FIN RÉPÉTER
FIN
On ajoutera un deuxième algorithme qui se lancera si l’événement Lorsque le bouton A est appuyé est actif.
On effacera alors l’écran et on affichera « Détection d’un soulèvement ».
La figure 2–8 montre le code associé.
Votre programme est prêt ; il vous suffit de cliquer sur le bouton Téléverser. Vous pourrez régler vos niveaux
de seuil de détection. Sans bouger, la carte ne doit pas détecter de mouvement.
20
CHAPITRE 2. Programmer la carte Galaxia
Figure 2–8 – Programme de détection d’un mouvement vertical de la carte.
Gérer le système
La carte Galaxia présente un bouton Système bleu en
haut à droite (figure 2–9). Ce bouton est actif à tout
moment.
Il donne accès à un menu : Figure 2–9 – Bouton Système de la carte Galaxia.

• La dernière erreur (permet de visualiser les éventuelles erreurs).
• Fichier à exécuter. Il est possible de sauvegarder plusieurs fichiers en Python et de lancer celui que l’on
veut (code.py par défaut). Lorsque vous cliquez sur le bouton Téléverser, le programme en blocs est en
fait traduit en Python, qui est ensuite enregistré sous code.py (par défaut).
• Variables. Pour visualiser le contenu des variables pendant l’exécution du programme pour déboguer.
• Boutons. Montre l’état des différents boutons, appuyés ou relâchés.
• LED. Affiche les codes RVB (rouge, vert, bleu) envoyés à la diode électro-luminescente.
• Capteur. Fournit un état des différents capteurs de la carte.
• Redémarrer la carte avec le fichier de démarrage spécifié précédemment.
21
Ressources en vidéo
Des vidéos d’explications sont disponibles sur YouTube en tapant le mot-clé « thingz galaxia » ou à l’adresse
suivante (figure 2–10) :
https://www.youtube.com/channel/UCZ6GpqkvQo9kwQ6R_GyVZzQ
Ce site va accueillir progressivement des vidéos complémentaires sur différents thèmes.
Figure 2–10 – Vidéos sur la carte Galaxia.
Interface de développement Vittascience

Il est aussi possible de programmer la carte Galaxia avec une autre inter-
face de développement en cours de création.
Pour cela, connectez-vous sur le site de Vittascience (figure 2–11) : https://

fr.vittascience.com/
Ce site est très proche de celui présenté précédemment. Il devrait en plus

proposer un simulateur en ligne sans avoir besoin de la carte pour valider
le fonctionnement des programmes.
Vittascience
Figure 2–11 – IDE Vittascience.
22
3 Lampe connectée
Le plus simple pour comprendre comment fonctionne un objet connecté est tout simplement d’en mettre
un en œuvre et de le tester en conditions réelles. Dans ce chapitre, vous allez utiliser la carte Galaxia pour
commander une lampe à distance à partir d’un smartphone ou d’une tablette.
Il est facile de transformer la carte Galaxia en lampe connectée, car elle possède une DEL (diode électro-
luminescente) de couleur qu’il sera possible de piloter à distance.
Créer un réseau
Il faut dans un premier temps créer un réseau, c’est-à-dire un ensemble de périphériques reliés avec ou
sans fil afin d’échanger des données.
La carte Galaxia possède nativement une connexion à un support de connexion sans fil Wi-Fi (figure 3–1).
Figure 3–1 – Éléments de la carte Galaxia.
Nous utiliserons un point d’accès sans fil Wi-Fi et le réseau TCP/IP (sur lequel nous reviendrons plus tard)
afin de relier notre lampe connectée à un smartphone ou une tablette (figure 3–2).
23
Figure 3–2 – Schéma du réseau de la lampe connectée.
Le point d’accès sans fil sera par exemple la box de votre domicile.
Connectez votre smartphone ou tablette à votre point d’accès, si cela

n’a pas été déjà fait : dans les paramètres, choisissez le menu Wi-Fi et
réseau, sélectionnez le SSID (nom de votre réseau Wi-Fi) dans la liste
affichée et entrez le mot de passe.
Figure 3–3 – Liste des SSID disponibles.
Identifier les éléments du réseau

Lorsque vous souhaitez vous rendre chez un ami, vous devez connaître son adresse postale, qui est unique
au monde. Sur un réseau informatique, c’est la même chose : il faut que chaque périphérique soit identifié.
Pour cela, on attribue à chacun ce qu’on appelle une adresse IP. Actuellement, on utilise des adresses IPV4
du type 192.168.1.15, mais on bascule progressivement vers des adresses IPV6. Nous n’aborderons pas ce
nouveau format dans cet ouvrage ; sachez juste qu’il permet d’augmenter le nombre d’adresses IP dispo-
nibles dans le monde.
Adresse IP du smartphone et du point d’accès

Pour connaître les adresses IP de ces périphériques, vous pouvez installer l’application PingTools sur votre
smartphone ou tablette (figure 3–4).
Figure 3–4 – Installation de PingTools.
24
CHAPITRE 3. Lampe connectée
Lancez l’application. Vous visualisez l’adresse IP de votre

smartphone ou tablette à gauche (192.168.1.23 sur la
figure 3–5) et celle de votre point d’accès sans fil au centre
(ici, 192.168.1.1). L’adresse IP de droite correspond à celle
qui est « visible » sur Internet (ici 81.220.249.142).
Figure 3–5 – Adresses IP des périphériques.
Adresse IP de la carte Galaxia

Il va falloir créer un petit programme à téléverser dans la carte Galaxia pour lui permettre de se connecter
à votre point d’accès.
1. Connectez-vous sur le site https://play.thingz.co/galaxia.
2. Glissez-déplacez la commande de connexion en saisissant le SSID et le mot de passe de votre box

(figure 3–6).
Figure 3–6 – Programme pour se connecter au point d’accès (box).
3. Connectez votre carte Galaxia à votre ordinateur

via le câble USB.
4. Copiez le programme dans la carte Galaxia en

cliquant sur le bouton en haut à droite Téléverser Figure 3–7 – Bouton Téléverser.
(figure 3–7).
5. Le programme se téléverse dans la carte, puis se lance automati-

quement.
Si tout s’est bien passé, vous devriez visualiser l’adresse IP sur l’écran
de la carte Galaxia (figure 3–8). Sinon, une erreur s’affiche. Une des
causes possibles peut être une erreur dans le SSID ou le mot de passe
que vous avez saisi.
Figure 3–8 – Visualisation de l’adresse IP
de la carte Galaxia, ici 192.168.0.100.
25
Visualiser les adresses IP sur le réseau local

Vous allez maintenant visualiser les différents périphériques que
vous venez de connecter sur votre réseau local. Pour cela, lancez
à nouveau l’application PingTools. Cliquez cette fois-ci sur l’icône
du menu en haut à gauche de l’application, puis sur Local-Area
Network.
Figure 3–9 – Menu réseau local sur PingTools.
Vous voyez maintenant les adresses IP des périphériques connectés
sur votre réseau local : votre lampe connectée (192.168.0.100 sur la
figure 3–10), votre smartphone, votre box et les éventuels autres
périphériques connectés à cette dernière.
Vérifier le réseau Figure 3–10 – Visualisation des adresses IP

d’un réseau sur PingTools.
Maintenant que vous avez identifié les adresses IP de vos périphériques, vous allez tester si les communi-
cations sont possibles. À cette fin, vous allez télécharger et installer l’application Ping sur votre tablette ou
smartphone (figure 3–11).
Figure 3–11 – Installation de Ping.
Lancez l’application. Saisissez l’adresse IP du destinataire, ici votre

lampe connectée (carte Galaxia 192.168.0.100 sur la figure 3–12), puis Figure 3–12 – Saisie de l’adresse IP d’un
destinataire sur Ping.
cliquez sur Start.
Vous pourrez obtenir deux types de réponses.

• Si l’application n’arrive pas à joindre le destinataire, elle affiche
request timed out (figure 3–13). Diverses raisons peuvent être
invoquées : erreur dans l’adresse IP saisie, erreur de connexion sur
le réseau, point d’accès inactif. Figure 3–13 – Réponse lorsqu’il n’y a pas
de destinataire joignable.
• Si l’application arrive à joindre le destinataire, cela signifie que votre
réseau est totalement opérationnel.
Sur la figure 3–14, on constate que l’application a envoyé 64 octets
au destinataire, qui a répondu en 409 ms. Donc, la communication
est possible entre périphériques.
Vous pouvez aussi utiliser Ping pour tester votre box.

Figure 3–14 – Réponse lorsque
le destinataire est joignable.
26
CHAPITRE 3. Lampe connectée
Mettre en œuvre la lampe connectée

Le réseau est totalement opérationnel maintenant ; il
est temps de tester votre lampe connectée. Pour cela,
il vous faudra installer une autre application, gratuite,
sur votre smartphone : TCP Client (que vous trouverez
sur le Playstore, figure 3–15). Figure 3–15 – Installation de TCP Client.
Du côté de la carte Galaxia, il vous faudra modi-

fier le programme précédent en y ajoutant un
code capable de recevoir une donnée au niveau
de la lampe connectée (figure 3–16). Si cette
donnée (message) reçue est on, alors on allumera
la DEL en blanc ; sinon, si on reçoit off, alors on
éteindra la DEL. Téléversez le programme dans
la carte Galaxia, qui démarrera.
Enfin, pour faire fonctionner votre nouvelle

lampe connectée, lancez l’application TCP Client
précédemment téléchargée (figure 3–17).
Figure 3–17 – Premier écran au lancement

de l’application TCP Client.
Vous voyez en haut à gauche l’adresse IP de

votre smartphone ou tablette. Cliquez en haut à
droite sur l’icône . Dans le champ Address, Figure 3–16 – Programme pour la lampe connectée.
saisissez l’adresse IP de la carte Galaxia (votre
lampe connectée).
N’oubliez pas de saisir le numéro du port, 2000 (figure 3–18). Puis,

revenez en arrière en utilisant la flèche retour d’Android généralement en
bas à gauche.
Figure 3–18 – Paramétrage pour
se connecter à la lampe.
Il ne vous reste plus qu’à vous connecter à votre lampe en cliquant sur
l’icône . Un message vous indique que l’opération a bien réussi
(figure 3–19).
Figure 3–19 – Affichage de la connexion
à la lampe.
Pour commander la lampe, il vous suffit de supprimer la commande par
défaut /n, de saisir la commande on ou off et de cliquer sur le bouton
d’envoi (figure 3–20). Vous devriez voir la lampe s’allumer et s’éteindre Figure 3–20 – Envoi d’une commande
à la lampe connectée.
suivant les codes envoyés.
27
Vous venez d’utiliser un protocole de communication, c’est-à-dire un ensemble de règles communes entre
un émetteur et un récepteur. Ici, le protocole définit qu’on allume la DEL si on envoie on et qu’on l’éteint
si on envoie off. Vous auriez pu choisir un tout autre protocole ; par exemple, éteindre lorsqu’on envoie 0
et allumer si on envoie 1.
28
4 Thermomètre connecté
Vous avez vu comment commander à distance un objet connecté.

Découvrons maintenant comment lire les données qu’il envoie, c’est-à-
dire la communication inverse. Dans l’exemple choisi, un thermomètre
connecté indiquera à distance la température à l’intérieur d’un réfrigérateur.
La carte Galaxia intègre un capteur de température peu précis au niveau du

microcontrôleur. Nous allons voir comment utiliser un capteur de tempé-
rature externe à la carte Galaxia qui, lui, sera plus précis.
Analyser le système
Une solution consiste à utiliser un capteur externe que l’on viendra
Figure 4–1 – Réfrigérateur connecté.
connecter sur un des deux connecteurs Grove de la carte (figure 4–2).
Chaque connecteur est identifié par un numéro (Grove1 et Grove2).
Figure 4–2 – Connecteurs Grove de la carte Galaxia.
Vous pourrez utiliser le capteur Grove avec un signal analogique en sortie

Seedstudio
(figure 4–3).
Si vous n’avez pas de capteur de température Grove, vous pourrez adapter le

Figure 4–3 – Capteur
code pour utiliser le capteur de température interne de la carte Galaxia. de température Grove.
29
Le diagramme de blocs interne est présenté sur la figure 4–4.
Figure 4–4 – Diagramme de blocs interne du capteur de température connecté.
Branchez votre capteur sur le connecteur Grove1. Vous remarquerez que le fil jaune (sortie nommée SIG,
signal analogique) qui relie le capteur à la carte arrive sur la broche P19. Il serait aussi possible de connecter
ce capteur sur une autre entrée analogique disponible : Grove2 sur l’entrée P7.
Tester le capteur
Le programme suivant (figure 4–5) va afficher la valeur de la température sur l’écran de votre carte Galaxia.
Figure 4–5 – Programme pour lire le capteur de température.
Modifiez la température au niveau du capteur en soufflant dessus.
Vous verrez alors la température varier toutes les secondes sur l’écran de
la carte Galaxia (figure 4–6).
Figure 4–6 – Affichage des valeurs

issues du capteur de température
Grove.
30
CHAPITRE 4. Thermomètre connecté
Mettre le capteur en réseau

Il faut maintenant relier ce capteur à un réseau. Pour cela, il suffit, de la même façon que pour la lampe du
chapitre précédent, de connecter le capteur de température à un point d’accès Wi-Fi, comme votre box.
Connectez aussi votre smartphone ou tablette à ce même point d’accès. Vous obtenez alors le schéma de
réseau de la figure 4–7.
Figure 4–7 – Schéma du réseau avec le capteur de température.
De la même façon que précédemment, vous pouvez programmer votre carte Galaxia pour qu’elle se connecte
au point d’accès de votre box avec ses SSID et mot de passe. N’hésitez pas à utiliser les applications PingTools
et Ping pour réaliser vos essais préliminaires afin de vérifier que votre réseau est bien opérationnel. Notez
alors les adresses IP de vos périphériques.
Programmer le capteur
Pour lire la température, il suffit d’utiliser l’application TCP Client déjà vue et d’envoyer la commande temp
au capteur connecté. Lorsque ce dernier reçoit cette commande, il renvoie alors la valeur de la température
lue au niveau du capteur Grove et l’affiche dans l’application TCP Client.
On a bien un dialogue client/serveur ; le client est le smartphone ou la tablette et le serveur est la carte
Galaxia (thermomètre connecté). Le diagramme de séquence associé est présenté à la figure 4–8.
31
Client Serveur
Figure 4–8 – Diagramme de séquence du capteur de température.
L’algorithme est le suivant :
DEBUT
Afficher « capteur de température »
Se connecter au point d’accès avec SSID et mot de passe
TANT QUE vrai
TANT QUE pas de requête reçue
Ne rien faire
FIN TANT QUE
SI requête= «temp » ALORS
Envoyer au client « température= » valeur capt temp Grove
FIN SI
FIN TANT QUE
FIN
Saisissez le programme suivant (figure 4–9) et téléversez-le dans la carte Galaxia.
Figure 4–9 – Programme du capteur de température connecté.
32
Réception d’un message
Vous aurez remarqué que, pour détecter l’arrivée d’une donnée au niveau du serveur, il faut attendre d’avoir reçu un message
(requête) qui se termine par un caractère spécial. Ici, le caractère est CR (Carriage Return qui signifie retour chariot).
En effet, lorsque vous saisissez une ligne dans un logiciel et que vous appuyez sur la touche Entrée, vous envoyez le carac-
tère spécial CR. Ce dernier indique au système la fin de votre message. Vous avez la possibilité de choisir entre plusieurs
caractères spéciaux pour délimiter votre fin de message ; nous y reviendrons.
Si vous ne définissez pas un caractère spécial de fin de message, alors le système va attendre une seconde pour vérifier qu’il ne
reçoit rien. C’est possible avec la commande Attendre qu’un message soit reçu dans message puis faire, mais cette méthode
est fortement déconseillée, car le système devra attendre une seconde. Donc la réponse possible ne sera pas instantanée.
Voilà, votre carte Galaxia est prête à fonctionner. Elle va attendre qu’un client vienne se connecter et
renverra la température.
Tester le capteur IoT

Avec un seul client
Votre thermomètre connecté est maintenant opérationnel. Pour
lire la valeur du capteur, lancez l’application TCP Client vue
précédemment (figure 4–10) et cliquez sur l’icône . Figure 4–10 – Lancement de l’application TCP Client.
Saisissez l’adresse IP de votre capteur de température, saisissez le numéro

de port 2000 (figure 4–11), puis revenez en arrière.
Adresses IP
Figure 4–11 – Paramétrage
Attention ! Les adresses IP notées ici ne sont pas forcément les mêmes que les de l’adresse IP du capteur dans
vôtres ; c’est tout à fait normal. TCP Client.
En effet, c’est un serveur spécial (présent dans le point d’accès), appelé serveur
DHCP, qui va choisir pour vous l’adresse IP de la carte Galaxia. On verra plus tard
qu’il est aussi possible d’imposer l’adresse IP statique de son choix.
Cliquez ensuite sur l’icône de connexion , qui devient .

Vous devez voir s’afficher le mot connected suivi de l’adresse IP
de la carte Galaxia (figure 4–12). Si ce n’est pas le cas, vérifiez
votre réseau et le bon fonctionnement du capteur. Figure 4–12 – Connexion établie avec le capteur
sur TCP Client.
Saisissez la commande temp dans la partie de gauche, puis le
caractère de fin de message après le + (figure 4–13). Ce carac-
tère ne s’écrit pas CR mais \r. Attention à la barre oblique Figure 4–13 – Envoi de la commande temp
inverse \ ; ne la confondez pas avec la barre oblique / ! Puis au capteur.
cliquez sur le bouton d’envoi.
33
Vous recevez alors la température renvoyée par le capteur à

votre smartphone ou tablette (figure 4–14).
Figure 4–14 – Réception de la température.
Les caractères de détection de fin de message
Vous aurez remarqué que, pour détecter l’arrivée d’une donnée au niveau du serveur, il faut attendre d’avoir reçu un message
(requête) qui se termine par un caractère spécial. Ici le caractère est CR.
Cas où il y a plusieurs clients

Vous pouvez déconnecter le client du thermomètre connecté ; il suffit de cliquer sur l’icône , qui devient
. Il est alors possible de se reconnecter au thermomètre à partir du même périphérique client ou d’utiliser
une autre tablette ou smartphone. En effet, un serveur peut accepter différents clients.
En fait, le serveur du thermomètre connecté ne pourra accepter qu’un seul client à la fois. Si un deuxième
client souhaite se connecter et prendre le contrôle, il faudra qu’il attende que le premier client se décon-
necte. C’est chacun son tour.
La figure 4–15 montre le schéma de réseau pour deux smartphones connectés à la carte Galaxia (thermomètre).
Figure 4–15 – Schéma du réseau avec deux clients.
Fonction d’un serveur
Il n’est pas possible pour le serveur de la carte Galaxia d’accepter plusieurs clients en même temps.
En fait, un « vrai » serveur peut accepter plusieurs clients en même temps ; c’est bien là tout son intérêt. Lorsque vous vous
connectez sur un site web comme https://meteofrance.com/, vous accédez à un tel serveur. Bien évidemment, il y a déjà
plusieurs clients connectés sur ce même serveur et qui consultent la météo en même temps que vous.
La limitation actuelle dans la carte Galaxia n’est là que par simplification du système, pour éviter d’indiquer qui envoie des
données au serveur et qui est le client.
34
Adresse IP du système connecté

Un périphérique est identifié par une adresse IP sur
un réseau informatique. Cette adresse est unique sur
le réseau local sur lequel est connecté le périphérique.
Jusqu’à maintenant, vous avez utilisé une commande

simple de connexion au point d’accès Wi-Fi sans
vous poser de question sur l’adresse IP de la carte
Galaxia (figure 4–16). L’adresse IP a été attribuée
automatiquement par un serveur DHCP (Dynamic
Host Configuration Protocol). Figure 4–16 – Adresse IP dynamique de la carte Galaxia
via serveur DHCP.
Il est aussi possible de choisir son adresse IP, qui

devient alors statique (figure 4–17).
Attention, il vous faudra alors vérifier que

l’adresse IP choisie n’est pas déjà attribuée à un
autre périphérique sur le réseau local. Pour cela,
vous pouvez utiliser l’application PingTools ou Fing
(figure 4–18), afin d’identifier les périphériques sur
votre réseau local.
Figure 4–17 – Choix d’une adresse IP statique pour la carte Galaxia.
Figure 4–18 – Application Fing.
Avec Fing, cliquez sur le bouton Rechercher des appareils

(figure 4–19). Vous obtenez alors la liste des périphériques
connectés sur votre réseau (figure 4–20).
Figure 4–19 – Commande pour lister

les périphériques sur Fing.
Figure 4–20 – Liste des périphériques sur Fing.
35
Sur la figure 4–20, vous visualisez le point d’accès Wi-Fi TP-link (192.168.0.1), ainsi que le smartphone
connecté (petit personnage à droite, 192.168.0.100) et la carte Galaxia (192.168.0.110). Il n’y a pas d’autres
périphériques. Si vous souhaitiez choisir une adresse IP pour la carte Galaxia, vous pourriez choisir entre
192.168.0.2 et 192.168.0.99 ou entre 192.168.0.101 et 192.168.0.254.
36
5 IoT sur une page web
Vous avez découvert qu’il est possible d’échanger des informations entre un objet connecté et une appli-
cation TCP Client.
Pour plus de facilité, on affichera les données d’un objet connecté sur une page web, qu’on consultera géné-
ralement dans un navigateur plutôt que sur application, où l’information est plus ou moins bien présentée.
Dans ce chapitre, vous allez donc découvrir comment créer une page web pour visualiser des données reçues
d’un objet connecté. Ainsi, vous comprendrez mieux le protocole HTTP qui permet de faire transiter des
pages web sur un réseau TCP/IP.
Notion de client/serveur sur un réseau

Imaginons un client dans un restaurant. Il appelle un serveur pour qu’il
prenne sa commande et ensuite lui livre les plats désirés. Un même
serveur peut être amené, dans un restaurant, à répondre à plusieurs
clients différents (figure 5–1).
Sur un réseau informatique, le même principe s’applique dans plusieurs

cas (figures 5–2 et 5–3). Le client initie l’échange, le serveur est à
l’écoute des requêtes d’éventuels clients.
Figure 5–1 – Dans un restaurant, un client

demande un plat à un serveur.
Serveur
requête
exécution
réponse du service
Client Serveur
Figure 5–2 – Schéma d’une relation client/serveur.

requête
client
réponses serveur
client
requête
Figure 5–3 – Demande de plusieurs clients
à un même serveur.
37
Dans les exemples précédents (lampe et thermomètre connectés), vous avez mis en œuvre cette structure
de client/serveur sans le savoir : la lampe ou le thermomètre était le serveur et la tablette ou le smartphone
était le client (figure 5–4).
Lampe Point Smartphone

connectée d’accès = client
= serveur sans fil
Figure 5–4 – Schéma de connexion de la lampe.
L’exemple concret le plus simple est l’utilisation d’un navigateur internet qui interroge un site web : le client
est le navigateur et le serveur est la machine qui héberge les pages web du site consulté.
Fonctionnement d’une page web

Pour l’utilisation d’un navigateur internet classique (Google Chrome, Firefox ou autre), le principe est le
même : le client est le navigateur et le serveur est la machine qui héberge votre page web.
Pour échanger des pages web, le protocole utilisé est le HTTP (HyperText Transfert Protocol). Le client envoie
une requête HTTP au serveur pour lui demander de lui renvoyer une page web. Cela nécessite de connaître
l’adresse IP ou l’URL du serveur. Ce dernier analyse la requête HTTP, puis y répond en renvoyant le code
HTML de la page demandée.
Attention, la notion de serveur implique une application qui fonctionne sur une machine pour écouter les
requêtes d’éventuels clients.
Programmer une page web sur la carte Galaxia

Afficher des informations sur une page web
Reprenons l’exemple qui consiste à détecter si on a déplacé un objet (chapitre 2). Si la valeur du capteur
est en dehors d’une plage prédéfinie, alors on considère que l’objet a été bougé. Ici, on va juste détecter si
la carte Galaxia est toujours à l’horizontale ou au contraire inclinée.
Programmer la carte Galaxia

Le principe est simple. Dans un premier temps, il faut connecter la carte Galaxia à un point d’accès Wi-Fi.
Puis, on sauvegarde dans une variable nommée ici acceleration la valeur du capteur de mouvement
suivant l’axe z (vertical).
38
CHAPITRE 5. IoT sur une page web
La carte Galaxia est un serveur. Elle va héberger une page web qui devra être modifiée régulièrement pour
afficher l’état de l’objet connecté. On utilise pour cela la commande Générer la page web. Dans cet exemple,
nous n’ajouterons qu’une simple ligne de texte grâce à la commande Ajouter le texte, mais on pourrait
présenter le résultat sous forme de jauge. Saisissez le programme de la figure 5–5, puis chargez-le dans la
carte Galaxia en cliquant sur le bouton Téléverser.
Figure 5–5 – Programme de détection d’un soulèvement de la carte.
Pour connaître l’adresse IP du serveur, il suffit de la lire sur l’afficheur au démarrage du programme. Elle
est nécessaire pour ensuite y accéder avec un simple navigateur.
Visualiser la page web

Lancez un navigateur internet, puis saisissez l’adresse IP de la carte Galaxia. Votre navigateur va alors
envoyer une requête GET pour demander une page web via le protocole HTTP.
Vous devez obtenir les exemples de pages des figures 5–6 et 5–7 en fonction de la position de votre carte
Galaxia. La mise à jour de l’information est automatique.
Figure 5–6 – Affichage de la page web « objet incliné ». Figure 5–7 – Affichage de la page web « objet horizontal ».
Commander un objet connecté sur une page web

Vous avez vu comment recevoir une donnée d’un objet connecté et l’afficher sur une page web. Découvrons
maintenant comment envoyer une donnée depuis la page web vers l’objet connecté. Pour cela, nous allons
reprendre l’exemple de la lampe connectée (chapitre 3).
39
Principe
La page web va afficher deux boutons : On pour allumer la lampe et Off pour l’éteindre. On affichera aussi
l’état de la lampe en retour. Le diagramme de séquence correspondant est présenté à la figure 5–8.
Figure 5–8 – Diagramme de séquence des échanges entre le serveur web Galaxia
et le navigateur client.
40

On utilise une variable etat_led pour mémoriser l’état de la DEL et on change la page affichée en fonction
de cet état (figure 5–9).
Figure 5–9 – Programme pour commander une DEL depuis une page web.
Tester la page web

Lancez un navigateur et demandez l’adresse IP de la carte Galaxia. Il vous suffit de cliquer sur le bouton
Eteindre LED ou Allumer LED pour commander votre lampe à distance (figures 5–10 et 5–11). L’état de la
lampe s’affiche avec le bouton correspondant ; on change bien la page web à chaque pression sur le bouton.
Figure 5–10 – Lampe allumée et bouton pour l’éteindre. Figure 5–11 – Lampe éteinte et bouton pour l’allumer.
41
Afficher une jauge sur une page web

Lorsque la valeur d’une donnée évolue entre un minimum et un maximum, on obtient un meilleur rendu
en l’affichant sous forme de jauge.
Reprenons l’exemple du capteur de température interne du microcontrôleur. L’affichage de la jauge se fera

entre 20 °C et 30 °C.

Saisissez le programme suivant :
Figure 5–12 – Programme pour afficher la jauge sur la page web.
La valeur de la jauge sera rafraîchie automatiquement. Ici, on utilise le capteur de température interne de
la carte Galaxia. Vous remarquerez qu’il est possible de fixer la valeur minimale et maximale de la jauge.
Ici min=20 et max=36.
Tester la page web

Il suffit de lancer un navigateur sur sa tablette ou son smart-
phone et de saisir l’adresse IP de sa carte Galaxia. On voit
alors bien l’affichage de la température sous forme de jauge.
Figure 5–13 – Affichage de la jauge sur la page web.
Commander la carte Galaxia avec une URL

Il est possible aussi d’envoyer des données au serveur de la carte Galaxia en utilisant le protocole HTTP.
Principe d’envoi d’une donnée

Pour cela, il suffit de saisir l’adresse IP de la carte Galaxia (192.168.0.100 dans nos exemples) suivi de
/votre_donnee. Par exemple, si vous saisissez http://192.168.1.100/on, le serveur de la carte Galaxia
récupérera la donnée envoyée, ici la commande on.
42
Voyons comment commander une lampe connectée avec ce principe d’envoi d’une donnée par la requête
HTTP.
Pour allumer et éteindre la DEL de la carte Galaxia, vous utiliserez le protocole suivant :
Protocole utilisé
État de la DEL
(donnée envoyée dans la requête)
Allumée on
Éteinte off
Le diagramme de séquence est présenté sur la figure 5–14.
Figure 5–14 – Diagramme de séquence de la lampe connectée.

L’algorithme est le suivant et se traduit par le programme de la figure 5–15 :
DEBUT
Se connecter au point d’accès SSID et mot de passe
Fixer une IP
TANT QUE vrai
TANT QUE aucune requête reçue en HTTP
Ne rien faire
FIN TANT QUE
SI fin de requête http = « on » ALORS
43
Allumer lampe
SINON SI fin de requête http = « off » ALORS
Éteindre lampe
FIN SI
FIN TANT QUE
FIN
Figure 5–15 – Programme pour commander une lampe avec une requête HTTP.
Pour allumer la lampe, il vous suffira de saisir l’adresse IP de votre carte Galaxia suivie de /on (figure 5–16).
Pour l’éteindre, l’adresse IP sera suivie de /off (figure 5–17).
Figure 5–16 – Exemple d’URL avec commande « on ». Figure 5–17 – Exemple d’URL avec commande « off ».
44
6 Échanger des données avec la carte Galaxia
Découvrons comment réaliser une application sur tablette ou smartphone pour échanger des informations
avec la carte Galaxia. Nous allons tout d’abord définir quel sera l’aspect de l’application sur l’écran. Ensuite,
nous créerons le programme associé. Pour finir, il faudra tester l’application avec la carte Galaxia afin de
vérifier que les échanges se font correctement.
Application à construire
Reprenons l’exemple de la lampe connectée. L’objectif est
de réaliser une application qui pilotera la DEL de la carte
Galaxia (figure 6–1).
Il faudra créer un réseau qui comprendra la carte Galaxia

(lampe connectée), une tablette ou smartphone et un point
d’accès Wi-Fi. Dans un premier temps, nous donnerons
l’adresse IP de la carte Galaxia (qui s’affiche sur l’écran).
Pour commander la lampe, nous devrons cliquer sur le

bouton Se connecter, puis sur Allumer LED ou Eteindre LED.
En retour, la carte Galaxia enverra une information sur son Figure 6–1 – IHM (interface homme-machine)
état. Puis il sera possible de se déconnecter de la lampe de l’application sur tablette ou smartphone.
(pour éventuellement se connecter à d’autres systèmes les
uns après les autres).
Dessiner l’application
Voyons tout d’abord les différents objets qui composent l’écran.
Définir la partie IHM
Cet ouvrage n’a pas vocation à expliquer en détail comment réaliser une application sur tablette ou smartphone. Pour plus
de détails, vous pourrez consulter le livre Créer des applis avec App Inventor paru aux éditions Eyrolles.
45
Connectez-vous sur le site http://ai2.appinventor.mit.edu/, cliquez sur

Commencer un nouveau projet et nommez votre projet (figure 6–2).
Figure 6–2 – Commencer un nouveau

projet sur App Inventor.
Insérez les objets constituant l’IHM (figure 6–1) en les glissant-déposant de la partie de gauche vers le cadre
intitulé Interface (figure 6–3).
Figure 6–3 – Interface sur App Inventor, partie Design.
Vous devez ensuite ajouter une extension (objet supplémentaire) qui

va permettre d’envoyer et de recevoir des données sur un réseau TCP/
IP. Pour cela, cliquez en bas à gauche sur Import extension (figure 6–4).
Figure 6–4 – Importation
de l’extension TCP.
Cliquez sur URL, puis saisissez l’adresse suivante : https://community.appinventor.mit.edu/uploads/short-url/
m5i3VtN9kcSyMlGnPAP4grOBBbT.aix. Il est aussi possible de télécharger le fichier clientsocketAi2ext.aix
depuis https:// www.editions-eyrolles.com/dl/0100822 et de cliquer sur From my computer (figure 6–5).
Figure 6–5 – Choix de l’extension TCP à importer.
46
CHAPITRE 6. Échanger des données avec la carte Galaxia
Une fois installée, vous devriez voir l’extension dans la liste en bas à gauche (figure 6–6).
Figure 6–6 – Visualisation de l’extension installée.
Glissez-déplacez-la dans la zone Interface, puis utilisez les différents objets

proposés dans l’Interface utilisateur (figure 6–7) pour construire les dialogues
d’interaction (figure 6–8).
Figure 6–7 – Palette des objets

disponibles.
Figure 6–8 – Interface à développer.
Fichier AIA complet
Si nécessaire, vous avez à votre disposition sur https://www.editions-eyrolles.com/dl/0100822 le fichier AIA complet à ouvrir
directement dans App Inventor.
47
Pour placer les objets les uns à côté des autres, utilisez dans la palette Interface
utilisateur l’objet Disposition>Arrangement horizontal (figure 6–9).
Vous pourrez donner des noms plus précis aux différents composants en
choisissant Renommer dans leur menu contextuel (clic droit sur les objets).
Cela facilitera la lecture du programme. Figure 6–9 – Disposition des objets.
Programmer l’application
Coder le programme
Dans l’IDE App Inventor, cliquez en haut à droite sur Blocs pour programmer votre application.
Il suffit de cliquer sur l’objet choisi et de sélectionner dans la liste une méthode ou un attribut. Repérez bien
les couleurs. Vous devez obtenir le programme de la figure 6–10.
Figure 6–10 – Programme en mode blocs.
Au lancement de l’application, on fixe l’adresse IP du serveur et on impose le port 2000. Si on appuie sur
le bouton de connexion, le système établit le contact avec la carte Galaxia.
Si on appuie sur le bouton allumer_led, le système envoie la commande on avec \r pour indiquer à la
carte Galaxia où se finit la commande. Si on appuie sur le bouton eteindre_led, le système va envoyer
la commande off suivie du code \r.
48
Ensuite, la carte Galaxia répond à la commande en envoyant l’état de la lampe LED allumée ou
LED éteinte.
Si on appuie sur le bouton de déconnexion, cela coupe le contact avec la carte Galaxia. Il est alors possible
de saisir une autre adresse IP d’une autre carte Galaxia pour s’y connecter
Téléverser le programme sur un smartphone ou une tablette

Cliquez maintenant sur le menu Construire, puis sur Android App (figure 6–11).
Téléchargez sur votre smartphone l’application MIT AI2 Companion :

https://play.google.com/store/apps/details?id=edu.mit.appinventor.
aicompanion3&hl=fr Figure 6–11 – Création du fichier
d’installation.
Lancez-la, puis cliquez sur Scan QR code. Flashez le QR code (figure 6–12). L’application s’installe.
Figure 6–12 – Flashage du QR code avec l’application.
Lorsque notre application est installée, elle se présente comme sur la figure 6–13.
Figure 6–13 – Application pour commander la lampe connectée sur tablette ou smartphone.
49
Utilisation sur IOS Apple
L’installation devrait être aussi possible sur IOS. Pour cela, téléchargez sur votre tablette ou smartphone l’application
suivante MIT App Inventor : https://apps.apple.com/fr/app/mit-app-inventor/id1422709355.

Vous utiliserez le même programme qu’au chapitre 5 pour commander la Galaxia via une URL à téléverser
dans la carte (figure 6–14). Il permet de lire une partie d’une requête HTTP. Nous allons simplement décoder
le message envoyé, on ou off.
Figure 6–14 – Programme pour commander une lampe connectée avec une requête HTTP.
On utilise le même principe de fonctionnement avec le même protocole de communication. Si la carte Galaxia
reçoit une requête GET avec la commande on en fin d’URL, on allume la lampe ; si on reçoit off, on l’éteint.
Téléversez le programme dans votre carte Galaxia, qui va se connecter à votre point d’accès.
50
Tester le système
Commencez par vérifier que votre point d’accès est disponible.
Alimentez la carte Galaxia. Le programme se lance et vous devriez visualiser sur l’écran l’adresse IP de la
carte. Connectez votre smartphone ou tablette au même point d’accès. Lancez l’application, puis saisissez
l’adresse IP de votre Galaxia.
Il vous suffit de faire des essais en appuyant sur les boutons Se connecter, Se déconnecter, Allumer LED et
Eteindre LED pour vérifier le bon fonctionnement de l’ensemble.
Pensez à vous déconnecter avant de fermer si vous voulez changer de périphérique.
51
7 U tiliser une plate-forme IoT
et le protocole MQTT
Jusqu’à maintenant, vous avez connecté un objet à un réseau. Pour envoyer (commander) ou recevoir
(visualiser) des données, vous avez utilisé des commandes simples ou programmé des applications.
Toutefois, le principal intérêt des systèmes IoT est de pouvoir centraliser les données et les présenter sur
une plate-forme. Ainsi, différents clients se connecteront facilement sur cette dernière afin de superviser le
système IoT. La lecture des données sera alors très facile à gérer et bien présentée.
Dans ce chapitre, vous allez découvrir comment programmer la carte Galaxia pour qu’elle envoie ou reçoive
des données sur une plate-forme dédiée, en utilisant le protocole MQTT.
Vous utiliserez deux plates-formes pour héberger des données : HiveMQ et Adafruit. Vous pourrez ainsi
visualiser la dernière donnée publiée par votre capteur et suivre très facilement son évolution sous forme
d’un graphique.
Protocole MQTT
Nous avons jusqu’à maintenant mis en œuvre un principe client-serveur : il fallait interroger un serveur afin
de recevoir en retour une donnée.
Imaginons que vous souhaitez vous abonner au compte Twitter d’une personne afin de la suivre. Cependant,
vous ne voulez pas consulter sans arrêt son compte pour vérifier si une nouvelle publication est disponible.
Vous souhaiteriez plutôt recevoir un simple e-mail qui vous en informerait (figure 7–1).
Figure 7–1 – Réception automatique de tweet.
53
1. Souscription
3. Lecture 2. Publication
Internaute lecteur Auteur du tweet

du tweet
Serveur
de Twitter
Figure 7–2 – Mécanisme de réception automatique d’un tweet.
De la même façon que pour suivre un compte Twitter (figure 7–2), dans une communication machine à
machine (M2M), il existe un protocole qui permet à des machines clientes de s’abonner à des données qui
ont été publiées. Le client utilise alors un serveur intermédiaire (broker), qui correspond à une application
en charge de la réception des informations publiées, afin de les retransmettre aux abonnés. Il met ainsi en
relation les souscripteurs et les publieurs.
Le protocole utilisé est le MQTT (Message Queuing Telemetry Transport). Il présente l’avantage d’être très
peu consommateur de bande passante sur un réseau. On peut connecter tous types de systèmes entre eux,
basés sur des technologies totalement différentes.
Figure 7–3 – Fonctionnement du protocole MQTT.
54
CHAPITRE 7. Utiliser une plate-forme IoT et le protocole MQTT
Voici les étapes du protocole MQTT.
1. Souscription (subscribe)
Un client s’inscrit à une ressource sur un serveur intermédiaire (broker), qui va héberger et centraliser
les données des objets connectés. Il s’agit d’un abonnement. Dès qu’une nouvelle donnée est disponible
sur le serveur, elle est envoyée au client abonné.
Cette ressource est localisée dans une arborescence appelée topic. Par exemple : /capteur/temp/.
2. Publication (publish)
Un client peut publier une donnée, ou un message (payload), comme une donnée de capteur. Cette
information va alors transiter vers le serveur intermédiaire, qui la redistribuera aux clients abonnés.
Il est possible de gérer la qualité de service (de transport des données) :

• niveau 0 = livré au mieux une fois ;
• niveau 1 = livré au moins une fois ;
• niveau 2 = livré exactement une fois.
Le protocole MQTT s’appuie sur TCP pour acheminer les données entre clients et intermédiaires.
Plate-forme HiveMQ
Vous allez découvrir le fonctionnement du protocole MQTT en utilisant un intermédiaire spécifique pour
échanger des données : HiveMQ.
Dans un premier temps, vous allez paramétrer votre client pour qu’il se connecte à votre serveur intermé-
diaire HiveMQ afin de préparer les données à afficher et leur format, texte, graphique. La deuxième étape
consistera à programmer la carte Galaxia qui fournira des données qui seront envoyées (publiées) en asso-
ciation avec un topic.
Cette plate-forme a été choisie en raison de sa simplicité d’usage et de présentation. Il ne sera possible
d’afficher des données que sous forme de textes ou de nombres. Le serveur ne nécessite aucun paramétrage,
ce qui est très confortable.
Le principe de fonctionnement est simple (figure 7–4) :
1. Un client souscrit à un topic (contenant les données recherchées), à l’aide d’un Subscribe.
2. Un autre client (objet connecté) publie une donnée (payload) sur une arborescence particulière, le topic.
3. L’intermédiaire envoie alors la donnée au client qui s’est inscrit au topic.
55
1
2
3
Consultation des données
du capteur
Capteur Broker (client = abonné)
(client) (serveur)
Figure 7–4 – Fonctionnement du protocole MQTT avec HiveMQ.
Souscrire à un topic HiveMQ

Nous allons paramétrer notre client pour qu’il soit prêt à recevoir une donnée publiée par un capteur
connecté.
Avec un PC, connectez-vous sur le site d’un client MQTT associé au serveur HiveMQ :
http://www.hivemq.com/demos/websocket-client/.
Saisissez le nom essai dans la partie Username, puis cliquez sur le bouton Connect.
Figure 7–5 – Connexion au serveur HiveMQ.
Cliquez sur le bouton Add New Topic Subscription.
Figure 7–6 – Ajout d’un nouveau topic sur le serveur HiveMQ.
56
Saisissez le nom du topic (temp1) sur lequel vous souhaitez vous inscrire et cliquez sur Subscribe.
Figure 7–7 – Saisie du nom du topic sur le serveur HiveMQ.
Vous êtes maintenant abonné aux données qu’enverra votre capteur de température (carte Galaxia).
Dorénavant, dès qu’une nouvelle donnée associée au topic temp1 arrivera au serveur, elle s’affichera auto-
matiquement dans votre espace client abonné.
Figure 7–8 – Affichage du topic choisi.
Rien ne se passe actuellement, car la carte Galaxia n’a pas encore été programmée pour publier une donnée
de température.
Programmer la carte Galaxia (IoT)

Vous devez programmer la carte Galaxia afin qu’elle publie vers le serveur une valeur de température à
chaque pression sur le bouton A.
Attention : lorsque vous connectez la carte Galaxia au serveur HiveMQ, ne saisissez pas le mot de passe
noté sur la figure 7–9, mais celui correspondant au ClientId qui est créé automatiquement sur le serveur.
Ce CLientId change en fonction de votre connexion !
Figure 7–9 – Connexion au serveur HiveMQ.
57
Saisissez le programme de la figure 7–10.
Figure 7–10 – Programme du capteur de température sur le serveur HiveMQ.
Dans un premier temps, on efface l’écran et la carte Galaxia se connecte au point d’accès, puis au serveur.
Ensuite, on affiche la connexion établie. Si on appuie sur le bouton A alors que la carte est connectée, on
envoie la température mesurée sur la carte associée au topic temp1.
Lire des données sur HiveMQ

Il vous suffit maintenant d’appuyer sur le bouton A de la carte pour visualiser dans la partie Messages les
valeurs de température qui s’affichent au fur et à mesure sur votre PC.
Figure 7–11 – Affichage des valeurs transmises par HiveMQ au client abonné.
Lire des données sur smartphone

Vous venez de voir comment visualiser sur ordinateur des données publiées sous forme de texte. Découvrons
comment présenter très simplement ces dernières sur une tablette ou un smartphone qui sera alors un client
MQTT. Il y a plus de possibilités de mise en forme pour présenter les données (payload) reçues.
58
Paramétrer le tableau de bord

Téléchargez sur votre smartphone l’application MQTT Dash :
https://play.google.com/store/apps/details?id=net.routix.mqttdash&hl=fr.
Figure 7–12 – Téléchargement de l’application MQTT Dash.
Lancez l’application, puis cliquez sur l’icône + pour ajouter une zone d’information.
Figure 7–13 – Ajout d’une zone de visualisation d’une donnée sur MQTT Dash.
Tapez le nom du serveur, puis son URL (affichée au démarrage du client) et cliquez sur l’icône de sauve-
garde en haut à droite.
Figure 7–14 – Saisie des coordonnées du serveur.
Cliquez sur le nom du serveur (broker), puis sur l’icône +.
Figure 7–15 – Ajout de l’affichage de la température associé au broker.
59
Vous allez maintenant choisir le type d’information que vous voulez voir sur votre tableau de bord. Plusieurs
formats sont proposés. Ici, vous allez afficher un texte : cliquez sur Text.
Figure 7–16 – Choix d’un type d’information à afficher sur le tableau de bord.
Saisissez le nom du capteur à visualiser ainsi que le topic auquel est associée la donnée qu’il envoie. N’oubliez
pas de valider vos informations en cliquant sur l’icône en haut à droite (figure 7–17). Vous voyez alors l’in-
formation au format texte en attente de la publication d’une nouvelle valeur de température (figure 7–18).
Figure 7–17 – Choix d’un topic.
Figure 7–18 – Affichage de l’information sur le tableau de bord.
Programmer le capteur de température

Il vous suffit de reprendre le même programme que précédemment (figure 7–10) pour que la carte Galaxia
soit un capteur de température connecté et puisse publier une donnée dès que l’on appuie sur le bouton A.
Visualiser la température sur le tableau de bord

Publiez une température en appuyant sur le bouton A de la carte Galaxia. Vous voyez alors la température
s’afficher sur le tableau de bord.
60
Figure 7–19 – Affichage de la température sur le tableau de bord.
Vous pouvez afficher la température sous forme de jauge (Range/progress) selon les mêmes principes.
Publier sur le serveur HiveMQ à partir d’un PC

Il est possible d’accéder au serveur MQTT HiveMQ et de publier manuellement des données à partir d’un PC.
Vous n’aurez donc besoin que d’une seule carte Galaxia, qui sera le client MQTT (figure 7–20).
1. Souscription
au topic
2. Publication
du topic
3. Réception
du topic
Serveur MQTT
Publication
Client MQTT
depuis un PC
Figure 7–20 – Schéma d’échange des données avec le protocole MQTT entre un PC et la carte Galaxia.
Saisissez le programme du client MQTT pour que la carte Galaxia se connecte sur le serveur HiveMQ
(figure 7–21).
61
Figure 7–21 – Publication d’une donnée associée au topic temp1.
Connectez-vous sur le site du serveur HiveMQ : http://www.hivemq.com/demos/websocket-client/. Dans la

partie Publish, saisissez le nom du topic : temp1 et la valeur de température, ici 24, puis cliquez sur le bouton
Publish (figure 7–22). La donnée s’affiche alors sur l’écran de la carte Galaxia (figure 7–23).
Figure 7–22 – Publication manuelle d’une donnée associée au topic temp1.
Figure 7–23 – Affichage de la température sur la carte cliente.
62
Plate-forme Adafruit
Vous avez mis en œuvre une première plate-forme IoT avec le serveur HiveMQ. Vous avez pu constater
que l’on ne pouvait afficher que des valeurs et une jauge, mais que les possibilités étaient limitées.
On souhaite maintenant afficher des informations sous forme d’une évolution graphique. Vous allez décou-
vrir une nouvelle plate-forme avec le serveur Adafruit afin d’afficher l’évolution du capteur de température.
Avec un client MQTT sur ordinateur

Créer un compte sur Adafruit
Connectez-vous sur le site : https://io.adafruit.com/. Cliquez sur Sign in (figure 7–24) puis sur Sign up
(figure 7–25).
Figure 7–24 – Création d’un compte Adafruit.
Figure 7–25 – Validation du compte Adafruit.
Créez un nouveau tableau de bord avec New Dashboard (figure 7–26), puis saisissez son nom et ses carac-
téristiques (figure 7–27).
Figure 7–26 – Création d’un nouveau tableau de bord.
Figure 7–27 – Paramètres du tableau de bord.
63
Cliquez sur le tableau de bord créé (figure 7–28) et créez un nouveau bloc graphique. Pour cela, cliquez sur
l’icône , puis sur Create New Block (figure 7–29).
Figure 7–28 – Sélection du tableau de bord créé.
Figure 7–29 – Création d’un nouveau bloc pour l’ajout d’une zone de graphique.
Créez une nouvelle zone de graphique en cliquant en bas à droite sur Live chart (figure 7–30), puis créez un
nouveau topic (Feed) et validez en cliquant sur Create (figure 7–31).
Figure 7–30 – Ajout d’une zone de graphique.
64
Figure 7–31 – Création d’un nouveau topic (feed).
Sélectionnez votre nouveau topic et cliquez sur Next step (figure 7–32).
Figure 7–32 – Sélection du nouveau topic (feed).
Paramétrez votre graphique (figure 7–33), puis finalisez en cliquant sur Create block (figure 7–34).
Figure 7–33 – Paramétrage du graphique.
65
Figure 7–34 – Validation de la création du graphique.
Vous allez redimensionner la taille de la fenêtre de votre graphique, qui est trop petite par défaut. Pour
cela, dans les outils, cliquez sur Edit layout (figure 7–35). Cliquez/tirez sur les bords pour redimensionner
la taille de la fenêtre (figure 7–36).
Figure 7–35 – Paramètres de la fenêtre graphique.
Figure 7–36 – Modification de la taille de la fenêtre.
La zone graphique pour montrer l’évolution de la température est prête sur votre client MQTT Adafruit.
Notez la clé associée à votre tableau de bord en cliquant sur My Key (figure 7–37) et mémorisez aussi le
nom d’utilisateur (figure 7–38).
Figure 7–37 – Accès à la clé du tableau de bord.
Figure 7–38 – Clé et nom d’utilisateur pour accéder au tableau de bord.
66
Programmer le capteur de température

Saisissez le programme suivant (figure 7–39), qui est quasiment le même que celui de la figure 7-10 : il suffit
juste de changer les paramètres du serveur, ainsi que ceux du topic. Le mot de passe a été copié précédem-
ment dans My Key.
Figure 7–39 – Programme du capteur de température MQTT avec le serveur Adafruit.
Nom du topic
Vous remarquerez que le nom du topic est de la forme username/feeds/nom_feed. Username est le nom
d’utilisateur saisi lors de la création de votre compte sur Adafruit et nom_feed est le nom du topic (feed).
Tester le capteur de température

Il vous suffit maintenant d’appuyer sur le bouton A de la carte Galaxia pour voir le graphique évoluer en
fonction de la température mesurée (figure 7–40).
Figure 7–40 – Graphique des données affiché sur le tableau de bord.
67
Si vous cliquez sur le titre du graphique Evolution de la température °C, vous obtenez tous les détails voulus,
ainsi que des réglages complémentaires (figure 7–41).
Figure 7–41 – Graphique des données affiché sur le tableau de bord.
Créer un client MQTT sur Galaxia
Principe de fonctionnement
Vous avez vu que l’on pouvait utiliser un client MQTT à l’aide d’un navigateur internet avec accès au cloud
du serveur ou avec une application Android. Il est aussi possible de recevoir des données de capteur sur
une carte Galaxia automatiquement dès qu’elles ont été publiées par une autre carte Galaxia ou tout autre
système capable de publier sur le topic voulu (figures 7–42 et 7–43).
Figure 7–42 – Diagramme de séquence avec un client Galaxia MQTT.
68
1. Souscription
au topic
2. Publication
du topic
3. Réception
du topic
Capteur de
Serveur MQTT Client MQTT
température
Adafruit Galaxia n° 2
connecté Galaxia
n° 1
Figure 7–43 – Schéma de connexion avec un broker entre deux cartes Galaxia.
Programmer le capteur de température pour publication

Nous avons déjà présenté le programme (figure 7–44).
Figure 7–44 – Programme du capteur de température sur carte Galaxia pour publication.
69
Programmer le client MQTT de la carte Galaxia

Ce programme permet à la carte Galaxia de souscrire à un topic, ici eyrolles/feeds/temp qui corres-
pond à la température publiée par l’autre carte Galaxia (figure 7–45).
Figure 7–45 – Programme du client MQTT sur carte Galaxia pour affichage de la température.
Tester le fonctionnement avec les deux cartes Galaxia

Retournez sur le site du serveur Adafruit et appuyez sur le bouton A de la carte du capteur de température.
Vous visualisez bien le graphique évolué comme vu précédemment (figure 7–46).
Figure 7–46 – Affichage de la température sur le tableau de bord Adafruit.
70
Vous constatez aussi, sur le capteur de température, la publication de la nouvelle donnée. Sur l’autre carte
Galaxia, qui joue le rôle de client MQTT, vous voyez s’afficher la même donnée sous forme de texte.
Figure 7–47 – Capteur de température connecté. Figure 7–48 – Affichage des données
sur la carte Galaxia cliente.
Créer une application pour smartphone avec le protocole MQTT

Pour plus de détails sur la programmation d’application avec App Inventor, vous pourrez consulter l’ouvrage
Créer des applis avec App Inventor, paru aux éditions Eyrolles.
Lire une température

Sur la carte Galaxia, reprenez le programme qui publie une température sur le serveur Adafruit (figure 7–49).
Figure 7–49 – Programme Galaxia MQTT pour publication de la température.
Pour créer l’application sur smartphone ou tablette, allez sur le site : http://ai2.appinventor.mit.edu.
Créez l’interface de la figure 7–50 en cliquant-déplaçant les objets voulus.
71
Figure 7–50 – Objets à insérer dans l’écran.
Un bouton sert à se connecter au serveur Adafruit ; on indique en dessous l’état actuel de la connexion. On
affiche la dernière valeur de la température, le nombre de données précédemment reçues et leurs valeurs
dans une liste.
Pour dialoguer, on utilise l’extension MQTT disponible sur le site suivant : http://ullisroboterseite.de/android-
AI2-PahoMQTT.html. Cliquez sur Extension, en bas à gauche, puis sur Import extension et choisissez l’extension
de.ullisroboterseite.ursai2pahomqtt.aix.
Il faut bien paramétrer l’objet MQTT pour spécifier le site du serveur (figure 7–51), ainsi que l’identifiant
(ici eyrolles) et le mot de passe qui est le my key sur Adafruit (figure 52).
Figure 7–51 – Nom du site du serveur. Figure 7–52 – Paramétrage de l’objet MQTT.
72
Cliquez ensuite sur la partie « blocs » qui vous permettra de programmer le système selon le code de la
figure 7–53. Les données de température sont sauvegardées dans une liste qui est ensuite affichée.
Figure 7–53 – Programme sur smartphone client MQTT.
Enfin, cliquez sur Construire, puis sur Android App (figure 7–54).
Figure 7–54 – Compilation du programme pour tablette ou smartphone.
Téléchargez sur votre tablette ou smartphone l’application MIT AI2 companion, puis flashez le QR code
créé. L’application s’installe ; il ne reste plus qu’à faire vos essais.
Commander une DEL depuis un tableau de bord

Créer le tableau de bord
Vous allez commander la DEL de la carte Galaxia à l’aide d’un bouton présent sur un tableau de bord.
Vous avez découvert qu’un tableau de bord était une présentation d’objets comme des capteurs et permettait
de recevoir les données publiées. Il est aussi possible de commander des actionneurs.
73
Cette fois-ci, vous allez publier des données associées à un topic bouton. Votre carte Galaxia (lampe
connectée qui jouera le rôle du client) qui aura souscrit au même topic, réagira aux données reçues du
serveur (figure 7–55).
Figure 7–55 – Diagramme de séquence pour piloter une DEL depuis un tableau de bord Adafruit.
Vous allez utiliser le serveur io.adafruit.com déjà vu. Connectez-vous à votre compte Adafruit. Créez un
nouveau tableau de bord pour afficher uniquement un bouton ON/OFF. Cliquez sur le menu Dashboard, puis
sur View all et enfin sur le bouton + New Dashboard (figure 7–56). Créez le tableau de bord lampe LED et
cliquez sur Create (figure 7–57).
Figure 7–56 – Création d’un nouveau Dashboard. Figure 7–57 – Description du nouveau tableau de bord Adafruit.
Sélectionnez le tableau de bord créé, puis créez un nouveau bloc en

cliquant à droite sur puis sur Create a new block. Sélectionnez
l’objet Toggle, qui donne un interrupteur à deux positions
(figure 7–58).
Figure 7–58 – Bouton dans le tableau

de bord pour piloter une DEL.
74
Créez ensuite le topic (feed) bouton qui servira à publier on ou off (figure 7–59) et sélectionnez-le
(figure 7–60).
Figure 7–59 – Création du topic bouton.
Figure 7–60 – Sélection du topic bouton.
Entrez les paramètres choisis pour définir le protocole : valeur on pour allumer, valeur off pour éteindre
(figure 7–61). Vous obtenez l’écran de la figure 7–62.
Figure 7–61– Définition du protocole pour piloter la DEL.
Figure 7–62 – Aspect du bouton dans le tableau de bord.
75
Vous pourrez accéder à votre tableau de bord depuis un simple navi-

gateur à partir d’un lien (URL). Pour cela, revenez sur votre tableau
de bord, puis cliquez sur de votre bouton (figure 7–63).
Figure 7–63 – Paramétrer l’accès public

ou privé au tableau de bord.
Changez l’état du bouton rouge Dashboard Privacy pour le positionner

sur le mode public (cadenas ouvert) en confirmant votre autorisa-
tion. Pour accéder au lien de partage, cliquez sur le menu Share Links
(figure 7–64).
Figure 7–64 – Lien d’accès public

au tableau de bord partagé.
Le lien est disponible (figure 7–65). Il suffit de le partager et de l’utiliser directement dans un navigateur.
Figure 7–65 – Lien d’accès public au tableau de bord partagé.
Programmer la carte Galaxia (client MQTT)

Vous utiliserez le même programme que précédemment (figure 7–66) pour créer une lampe connectée en
mode client MQTT. Toutefois, il faut bien vérifier que la connexion à votre point d’accès donne bien accès
à Internet. Votre carte Galaxia (lampe connectée) a souscrit au topic nommé bouton. Dès qu’une nouvelle
76
donnée, on ou off, arrive en provenance du serveur MQTT Adafruit, on allume ou éteint la lampe. La
donnée associée au topic bouton dépend de la sélection de l’interrupteur sur le tableau de bord.
Figure 7–66 – Programme sur smartphone pour commander une lampe avec le protocole MQTT.
Tester le tableau de bord sur un navigateur

Lancez le navigateur et saisissez le lien déjà vu : https://io.adafruit.com/eyrolles/dashboards/lampe-led
Attention, ce lien n’est pas forcément le même que le vôtre avec un identifiant différent !
Changez la position de l’interrupteur sur le tableau de bord et vérifiez que la DEL s’allume ou s’éteint.
Il est ainsi possible de piloter sa lampe de n’importe quel périphérique final (smartphone, tablette, PC)
connecté à Internet qui possède un simple navigateur. Il vous suffit de saisir le lien précédent pour accéder
à votre tableau de bord (page web) hébergé sur le serveur Adafruit. Cela vous évite de développer une
véritable page web, mais reste limité par rapport à une application pour tablette ou smartphone.
77
Commander une lampe via une application pour smartphone avec le protocole MQTT
De la même façon que vous avez créé une application pour visualiser des données d’un thermomètre
connecté, vous allez créer une application pour envoyer des commandes à une lampe connectée (figure 7–67).
Figure 7–67 – IHM pour commander une lampe connectée.
Saisissez le programme de la figure 7–68. On utilise deux images d’une lampe en modes allumé et éteint,
que l’on télécharge dans la partie Média>Charger fichier.
78
Figure 7–68 – Programme sur smartphone pour commander une lampe avec le protocole MQTT.
Cette fois-ci, vous utilisez la commande Publish pour envoyer on ou off au serveur Adafruit. Le programme
est le même sur la carte Galaxia pour piloter la DEL (figure 7–69).
Figure 7–69 – Programme sur carte Galaxia.
Testez votre système. Vous remarquerez qu’il est aussi possible de visualiser en même temps l’état du
bouton dans le tableau de bord Adafruit.
79
8 Commander un robot
Vous allez maintenant mettre en œuvre ce que vous avez appris dans les chapitres précédents et découvrir
comment piloter un robot : le Maqueen de DFRobot. Il sera possible de connecter la carte Galaxia en lieu
et place de la carte micro:bit sur le même connecteur.
Vous verrez comment commander un robot à distance. Pour cela, vous utiliserez une application Dashboard
à personnaliser ou vous créerez une application pour tablette ou smartphone ou encore développerez une
télécommande Galaxia avec les touches tactiles.
Vous utiliserez dans ces différents cas le protocole MQTT très pratique. Vous pourrez aussi récupérer des
informations en provenance des capteurs du robot.
Présentation du robot Maqueen

Ce robot de la société DFRobot est compact et accueille la carte Galaxia (figure 8–1). A4 Technologie
Figure 8–1 – Robot Maqueen avec carte Galaxia.
Ce robot existe en différentes versions en fonction des capteurs embarqués :

• capteur de distance à ultrasons ;
• capteurs de suivi de ligne ;
81
• capteur pour télécommande infrarouge ;

• codeurs pour compter le nombre de tours de roue ;
• DEL de couleurs RGB ;
• buzzer ;
• etc.
Piloter un robot avec une application Dashboard

Vous allez utiliser une application MQTT Dashboard à personnaliser pour commander le robot Maqueen
et le diriger dans les différentes directions.
Principe de pilotage
Ce robot est équipé de deux moteurs indépendants pour se déplacer. En pilotant indépendamment ces deux
moteurs, il sera possible de le diriger dans toutes les directions.
Vous allez créer un tableau de bord qui vous servira à piloter votre robot et à afficher en option la valeur
d’un capteur de suivi de ligne situé sous le robot (figure 8–2).
DFRobot
Figure 8–2 – Capteurs de suivi de ligne (1) et LED (5) du robot Maqueen.
Pour le diriger, on pourra le faire avancer ou reculer en pilotant les deux moteurs droit et gauche en même
temps dans le même sens de rotation. Pour le mettre en rotation à droite, il suffira de faire tourner le moteur
droit vers l’avant et le moteur gauche à reculons. On enverra les commandes par MQTT, selon le protocole
de pilotage suivant :
82
CHAPITRE 8. Commander un robot
Direction avancer reculer arrêter le robot
Commande publiée (payload) avancer reculer stop
Ces commandes de direction seront associées au topic eyrolles2022/direction. Ce dernier a été choisi
arbitrairement ; vous pouvez en choisir un autre. Le système utilisera un serveur intermédiaire (broker) sur
lequel seront publiées les données de direction. Le robot s’abonnera (Subscribe).
Créer l’application
Vous avez déjà vu une application du même type. Vous allez ici découvrir une autre application, similaire
mais plus complète et qui permet une personnalisation de votre écran très intéressante : MQTT Dashboard.
Téléchargez-la sur votre tablette ou smartphone.
Figure 8–3 – Application MQTT Dashboard.
Vous avez jusque-là communiqué avec deux serveurs intermédiaires : HiveMQ

et Adafruit. Vous allez cette fois-ci utiliser Mosquitto.
Figure 8–4 – Serveur Mosquitto.

Paramétrer le serveur
Lancez l’application. Commencez par paramétrer la connexion au serveur. Pour cela, cliquez sur le menu
en haut à gauche (figure 8–5), puis sur MQTT connections (figure 8–6) et, enfin, ajoutez une connexion au
serveur Mosquitto (figures 8–7 et 8–8).
Figure 8–5 – Menu sur MQTT Dashboard.
83
Figure 8–6 – Menu MQTT connections.
Figure 8–7 – Ajout d’un serveur.
Figure 8–8 – Paramètres du serveur.
Vous pouvez laisser le client ID tel qu’il est sur votre application, c’est-à-dire différent de celui sur la
figure 8–8. N’oubliez pas de valider en haut à droite !
Votre connexion doit être active ; vérifiez qu’il y a une icône en forme de nuage validé (figure 8–9).
Figure 8–9 – Vérification de la connexion au serveur Mosquitto.
84
Paramétrer le tableau de bord

Vous allez maintenant créer et personnaliser votre tableau de bord. Pour cela, cliquez sur le menu en haut
à gauche (figure 8–10), puis sur le menu Dashboards (figure 8–11), sur le + (figure 8–12) et enfin, donnez un
nom à votre tableau de bord (figure 8–13) et validez.
Figure 8–10 – Menu sur MQTTDashboard.
Figure 8–11 – Accès au menu Dashboard.
Figure 8–12 – Ajout d’un tableau de bord.
Figure 8–13 – Nom du tableau de bord.
Entrez dans votre tableau de bord (figure 8–14), puis sélectionnez l’objet à insérer, ici un bouton-poussoir
(figure 8–15). Saisissez les informations demandées (figure 8–16).
85
Figure 8–14 – Sélection du tableau de bord à paramétrer.
Figure 8–15 – Insertion d’un bouton dans le tableau de bord.
Figure 8–16 – Paramétrage du bouton.
86
Vous remarquerez que l’on a saisi le topic

eyrolles2022/direction. En fait, vous pouvez
choisir ce que vous voulez comme nom, à condition de
bien préciser le même dans le programme de la carte
Galaxia.
Puis paramétrez l’aspect du bouton avec le choix de

l’icône en forme de flèche vers le haut pour matérialiser
le fait d’avancer (figure 8–17).
Figure 8–17 – Paramétrage de l’aspect du bouton.
Ici, la donnée publiée est avancer, selon le protocole

de communication décidé précédemment. Supprimez
l’affichage du temps (figure 8–18).
Figure 8–18 – Suppression de l’affichage du temps sur le bouton.
N’oubliez pas de valider en cliquant sur l’icône de

validation en haut à droite (figure 8–19). Vous devez
obtenir le résultat de la figure 8–20.
Figure 8–19 – Validation de l’objet bouton.
Figure 8–20 – L’objet bouton dans le tableau de bord.
87
Cette application vous permet aussi de modifier la taille et la position de l’objet dans votre écran. Pour cela,
il vous suffit de cliquer sur le bouton (figure 8–21) puis de le cliquer/déplacer ou de cliquer/déplacer le coin
en bas à droite pour le redimensionner (figure 8–22).
Figure 8–21 – Objet bouton dans le tableau de bord.
Figure 8–22 – Modification de la position et de la taille du bouton.
Procédez de la même façon pour les autres boutons, en prenant garde à préciser la bonne donnée à envoyer
(payload) selon le tableau définissant le protocole de commande du robot (figure 8–23).
Figure 8–23 – Tableau de bord avec les boutons de commande.
Votre application est maintenant prête à fonctionner.
88

Passez maintenant à votre robot qui va accueillir la carte Galaxia. Cette dernière va s’abonner au topic
eyrolles2022/direction. Dès qu’elle recevra une donnée, elle analysera la commande et dirigera le
robot en conséquence.
Il n’y a rien de nouveau par rapport aux programmes vus précédemment pour gérer le protocole MQTT
(figure 8–24). La gestion de l’événement « réception d’un message » se traduit par le traitement des dépla-
cements. Les affichages du topic et du message ne sont là que pour vérifier que tout se passe bien.
Figure 8–24 – Programme pour piloter le robot Maqueen.
Téléversez le programme dans la carte Galaxia et placez cette dernière dans son emplacement, puis allumez
le robot. Vérifiez que la carte se connecte bien à votre point d’accès et que, sur l’écran, s’affiche le message
Connecté au Broker Mosquitto.
89
Tester le pilotage
Il ne vous reste plus qu’à appuyer sur les boutons avancer, reculer ou stop pour piloter votre robot.
En procédant comme expliqué dans ce chapitre, il vous sera possible de piloter un même robot à partir de
plusieurs tablettes ou smartphones ou, à l’inverse, de piloter plusieurs robots qui exécuteront les mêmes
déplacements en même temps.
Vous pouvez bien sûr compléter à votre guise ce programme pour faire tourner le robot et ajouter l’affichage
des données de capteurs.
Pour aller plus loin

Pour piloter d’autres robots, il vous suffira de recourir aux commandes qui leur sont spécifiques, en les
développant progressivement selon les mêmes principes. Citons notamment le robot CODO de la société
A4 Technologie qui se programme de la même façon et qui peut accueillir aussi la carte Galaxia.
Figure 8–25 – Robot CODO.
Vous pourrez créer une télécommande avec une deuxième carte Galaxia, en utilisant les boutons tactiles
pour envoyer des ordres à votre robot (figure 8–26). Vous pourrez aussi utiliser le protocole HTTP pour
envoyer directement vos commandes, par exemple http://192.168.1.10/avancer ou http://192.168.1.10/reculer,
si l’adresse IP 192.168.1.10 est celle de votre robot.
Robot Point Télécommande

Maqueen d’accès avec boutons
sans fil tactiles
Figure 8–26 – Schéma du réseau pour commander le robot à partir de la carte Galaxia.
90
Vous pourrez développer une application Android en insérant différents boutons pour piloter votre robot
de la même façon en utilisant l’extension MQTT déjà vue (figures 8–27 à 8–29). C’est à vous de créer votre
protocole.
Figure 8–27 – Interface pour piloter le robot Maqueen sur APP Inventor.
N’oubliez pas de choisir le bon serveur intermédiaire (figure 8–28) !
Figure 8–28 – Paramétrage de l’extension MQTT sur l’interface d’APP Inventor.
91
Figure 8–29 – Programme pour piloter le robot Maqueen sur APP Inventor.
Vous pourrez aussi vous initier à la programmation Python en analysant progressivement vos programmes
réalisés en code Blocs et en étudiant leur traduction en code Python (figure 8–30).
Figure 8–30 – Passage de la programmation par Blocs en code Python.
92
Si vous voulez découvrir le langage Python, vous pourrez consulter le livre Python pour la carte micro:bit
(éditions Eyrolles), qui s’adapte très bien à la carte Galaxia.
C’est à vous maintenant d’inventer vos propres objets connectés…
93

Mon Premier Objet Connecté Découvrir Les Réseaux Informatiques

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Mon Premier Objet Connecté Découvrir Les Réseaux Informatiques

Transféré par

Droits d'auteur :

Formats disponibles

  

    

J. LAUNAY. – Les réseaux informatiques par la pratique.

J. LAUNAY. – Créer des applis avec App Inventor.

J. LAUNAY. – Python pour la carte micro:bit.

E. BARTMANN. – Le grand livre d’Arduino (4e édition).

J. BOYER. – Réparer son électroménager et ses autres appareils électriques.

R. SARAFAN. – Robots DIY.

D. NIBART. – 46 activités avec le mBot2.

D. NIBART. – 45 activités avec le mBot.

D. NIBART. – 30 défis robotiques.

D. NIBART. – 50 activités avec la carte micro:bit.

J.-B. BOICHAT. – Programmer en Java pour le Raspberry Pi 3.

J.-M. MOLENAAR et M. SABOURDY. – Les machines à commande numérique.

J. BOYER. – Réparez vos appareils électroniques (2e édition).

C. PLATT. – L’électronique en pratique (2e édition).

M. BERCHON. – Le grand livre de l’impression 3D.

75240 Paris Cedex 05

© Éditions Eyrolles, 2022

Si l’IoT (Internet of Things) évolue, c’est grâce à différents facteurs :

1 Qu’est-ce qu’un objet connecté ?.............................................................................. 11

2 Programmer la carte Galaxia..................................................................................... 17

5 IoT sur une page web................................................................................................. 37

Programmer une page web sur la carte Galaxia.............................................................................................. 38

6 Échanger des données avec la carte Galaxia............................................................ 45

7 Utiliser une plate-forme IoT et le protocole MQTT.................................................... 53

Pourquoi un monde connecté ?

L’IoT s’appuie sur :

Composition d’un système pour l’IoT

Figure 1–1 – Organisation schématique de l’IoT.

Réseaux utilisés par l’IoT

Figure 1–2 – Taux d’utilisation des différents supports de communication.

Créer son propre réseau IoT

Le support de connexion utilisé est le Wi-Fi.

Il est nécessaire d’avoir une connexion à Internet. On ne peut

pas faire fonctionner ce système sur un réseau local seul.

Figure 1–4 – Carte IOTBIT.

Pour plus d’information

Pour plus d’information

Le support de connexion utilisé est le Wi-Fi.

Le support de connexion utilisé est le Wi-Fi.

Figure 1–7 – Carte ESP32 DevkitC.

Cartes de type SIM 800

Le support de connexion utilisé est un réseau 2G,

Figure 1–8 – Carte de type SIM 800.

Le support de connexion utilisé est le Wi-Fi.

Figure 2–1 – Aspect de la carte Galaxia.

Connexions Prise USB vers

Figure 2–2 – Éléments composant la carte Galaxia.

Figure 2–3 – Interface pour programmer la carte Galaxia.

La méthode est assez classique.

1. Analysez votre cahier des charges.

3. Identifiez les différents événements associés à votre projet.

4. Pour chaque événement, rédigez un algorithme.

5. Codez chaque algorithme.

6. Téléversez le code dans la carte.

8. Testez votre programme sur un jeu de tests.

Sur certains IDE, on peut lancer un simulateur de la cible.

Dans notre cas, le soulèvement modifiera l’accélération suivant l’axe

Figure 2–5 – Programme pour visualiser

Pour téléverser le programme dans la carte Galaxia,

Vérifiez que le bouton Connecté à la carte est bien vert

Votre programme est alors transféré sur la carte et s’exé-

On voit bien que l’axe z correspond à la verticale.

7 Utiliser une plate-forme IoT et le protocole MQTT.................................................... 53