Info Embarquee Objets Connectes

Lycée polyvalent Saint-Eloi
9 avenue Jules Isaac

13100 Aix-en-Provence
Sciences Numériques et Technologie
Thème : Informatique embarquée et objets connectés
Bruno Masi
bruno.masi@ac-aix-marseille.fr
Consignes de travail
Ce document est à la fois un support de cours et d’activités. Les réponses aux questions doivent
être faites dans votre cahier de SNT.
Afin de faciliter la relecture de votre travail :

– Vous apporterez le plus grand soin à la rédaction
– Vous respecterez la numérotation des questions.
– Vous noterez avec soin les corrections données en classe, et tout particulièrement celle de la
synthèse.
Des logos vous permettront d’identifier le type de travail à effectuer :
Questions : vous devez répondre aux questions posées dans votre cahier de SNT.
A faire : vous devez effectuer les manipulations et expérimentations proposées. Vous devez
noter les résultats obtenus et dans votre cahier de SNT.
Synthèse : vous devez réfléchir aux questions et noter les réponses dans votre cahier de SNT.
Rev : 1.0
Date : décembre 2022
Ce document à été rédigé en LATEX avec l’éditeur Texworks et la distribution MiKTeX. Il a été compilé le 27 août
2023, 8 h 14 CEST.
Table des matières
Consignes de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1 La programmation en langage Python 5

1.1 Programmation en ligne avec Online-GDB . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1 Affectation des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.2 Affichage des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.3 Type des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.4 Saisir des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.5 Saisir des variables numériques . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.6 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3 Les conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Les structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4.1 La structure conditionnelle « if » . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.4.2 La structure conditionnelle « if-else » . . . . . . . . . . . . . . . . . . . . . 11
1.4.3 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Les structures itératives (boucles) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5.1 La boucle non bornée « while » . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5.2 La boucle bornée « for » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5.3 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 L’informatique embarquée 14
2.1 La carte Galaxia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.1 Le menu système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Programmation de la carte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.1 Un premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.2 Changement de couleur progressif . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.2.3 Acqusition des données issues de l’inclinomètre . . . . . . . . . . . . . . . . . . 17
2.2.4 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3 Les objets connectés 19

3.1 Mise en réseau des cartes Galaxia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Serveur WEB embarqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Une lampe connectée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.4 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Introduction
Le terme informatique embarquée désigne les matériels et logiciels implantés dans des systèmes
n’ayant pas une vocation purement informatique.
L’informatique embarquée est présente dans de très nombreux équipements que nous utilisons quo-
tidiennement. Par exemple, dans une machine à laver le linge, l’ensemble du cycle de lavage est – le
plus souvent – contrôlé par un microprocesseur exécutant un programme spécifique.
L’architecture d’un système informatique embarqué est donné à la figure 1 :
Interface
utilisateur
Système
Capteurs Unité de traitement Actionneurs
physique
Figure 1 – Architecture d’un système informatique embarqué

On y retrouve toujours les mêmes constituants :
– des capteurs Ils permettent de mesurer des grandeurs physiques (température, position, pression,
...) dans le système et de les retransmettre au système de traitement. Dans le cas d’un lave
linge il y aura, par exemple, un capteur permettant de mesurer la température de l’eau dans la
cuve afin de respecter les consignes de lavage.
– des actionneurs Ils servent à agir sur le système physique à contrôler. Dans le cas de la machine à
laver, il faut pouvoir faire tourner le tambour contenant le linge à l’aide d’un moteur ou chauffer
l’eau avec une résistance. Le moteur et la résistance sont tous les deux des actionneurs.
– une unité de traitement Il s’agit d’un micro-contrôleur ou d’un SOC (System On Chip), c’est à
dire d’un micro-ordinateur complet mais de faible puissance qui comporte au moins les éléments
suivants :
– De la mémoire de masse dans laquelle se trouve le programme à exécuter,
– De la mémoire vivre qui contient les données temporaires à traiter,
– Un microprocesseur,
– Des interfaces d’entrées/sortie qui permettent au système de communiquer avec l’extérieur.
Ce sont sur ces interfaces que se connectent les capteurs, les actionneurs ainsi que l’interface
utilisateur.
– une interface utilisateur Elle permet à l’utilisateur d’interagir avec le système. Elle peut être
très simple, avec seulement quelques boutons et des voyants lumineux, ou plus complexe, par
exemple avec un écran tactile.
Depuis quelques années les systèmes informatiques embarqués peuvent être dotés d’une interface de
communication (wifi, bluetooth, etc..) qui leur permet parfois d’être connectés au réseau internet. On
parle alors d’objets connectés. Les applications de ces objets connectés sont innombrables, on peut
citer par exemple les domaines de la domotique, de la télésurveillance, de la santé...
Le nombre croissant d’objets connectés via internet a fait émerger l’idée d’un internet des objets ou,
en anglais, internet of things abrégé souvent en IoT.
Informatique embarquée et objets connectés 4/23 S.N.T

Chapitre 1
La programmation en langage Python
Pour qu’un ordinateur puisse effectuer une tâche, par exemple un calcul, ou la résolution d’un pro-
blème, il faut le programmer, c’est à dire lui donner une suite d’instructions simples qui, lorsqu’elles
seront exécutées conduiront à l’accomplissement de la tâche.
Les programmes sont écrits dans des langages informatiques dont les mots sont des instructions et les
règles la syntaxe. Il existe de nombreux langages de programmation. Pour les « petits systèmes » tels
que les objets connectés on utilise le plus souvent le langage C ou C++ cependant, l’augmentation
des capacités de calcul et de la vitesse des micro-contrôleurs et des SOC permettent d’employer des
langages de plus haut niveau (plus abstraits) comme le langage Python.
1.1 Programmation en ligne avec Online-GDB

Le site Online-GDB permet d’écrire et d’exécuter du code Python sans avoir à installer Python sur
son ordinateur. Nous allons l’utiliser pour nous familiariser avec ce langage. Vous pouvez accéder à
Online-GDB avec l’url : https://www.onlinegdb.com/online python debugger
3 4
Figure 1.1 – Écran de GDB
L’écran de Online-GDB est séparé en deux parties repérées « 1 » et « 2 » sur la figure 1.1 :
– Partie 1 : Zone d’édition du programme, vous pouvez écrire votre programme dans cette partie
de la fenêtre.
– Partie 2 : Zone de sortie, sur laquelle s’affichent les résultats de l’exécution du programme.

De plus, nous utiliserons deux boutons :
– Le bouton Run repéré « 3 » sur la figure 1.1 : permet de lancer l’exécution du programme.
– Le bouton Download repéré « 4 » sur la figure 1.1 : permet de sauvegarder votre travail. Vous
devez impérativement enregistrer le travail que vous allez faire lors des exercices.
A faire
1.1 Connectez vous sur le site Online-GDB, modifiez le texte du message « Hello World ! »
en le remplaçant par celui de votre choix. Cliquez sur le bouton « Run » et vérifiez que
votre message s’affiche dans la zone de sortie.
1.2 Sauvegardez ce travail sur votre ordinateur en donnant au fichier le nom programme1.py.
1.2 Les variables

1.2.1 Affectation des variables
Pour écrire un programme, il faut enregistrer les données nécessaires au traitement dans des espaces
mémoires. Les variables sont des emplacements de stockage. Dans un programme elles sont repérées
par des noms et prennent des valeurs qui peuvent évoluer au cours du temps.
Lorsque l’on stocke une valeur dans une variable, on dit que l’on affecte la variable. En python cette
opération se fait à l’aide du signe =.

1 a = 3 # On affecte la valeur 3 à la variable a
2 b = 5 # On affecte la valeur 5 à la variable b
3 c = a + b # On calcule la somme du contenu des variables a et b
4 # et on affecte le r é sultat (8) à la variable c

Listing 1.1 – Différentes affectations de variables
Questions
On donne le programme :

x = 1
y = 2 + x
z = 2 * y + x

1.3 Sans utiliser l’ordinateur, donnez le contenu des variables x, y et z après l’exécution du
programme.
On donne le programme :

x = 1
x = x + 2

1.4 Sans utiliser l’ordinateur, donnez le contenu de la variable x, après l’exécution du pro-
gramme.
1.2.2 Affichage des variables

Comme nous l’avons vu à la question 1.1 l’instruction print permet d’afficher un message sur la
console de sortie. Il est également possible, avec print, d’afficher le contenu d’une variable.

1 a = 3
2 print ( a ) # Affiche le contenu de a -> 3
3 print ( " a " ) # Affiche le carat è re a -> a
4 print ( " a = " ,a ) # Affiche le message a = suivit de la valeur de a -> a = 3
5 print (a , 2* a ) # Affiche la valeur de a et son double -> 3 6

Listing 1.2 – Exemple d’utilisation de print pour affichier des variables
On remarque deux choses :
– lorsque l’on écrit print(a) le contenu de la variable a est affiché, mais si l’on écrit print("a")
c’est le caractère a qui est affiché. De même, lorsque l’on écrit print("a = "), tout le message
a = est affiché « tel quel ».
– il est possible de faire afficher plusieurs informations par print en séparant ces informations
par des virgules.
A faire
Copiez le programme ci-dessous dans l’éditeur de Online-GDB :

x = 3
y = 4
p = x * y
print ( " Le produit de x par y vaut p " )
print ( " Le produit de x par y vaut " , p )

1.5 Que constatez-vous ? Pourquoi le fonctionnement du premier print n’est-il pas satisfai-
sant ?
1.6 Modifiez le programme pour qu’il affiche :
Le produit de x par y vaut 12 et sa somme vaut 7
1.2.3 Type des variables

Une variable peut, comme nous venons de le voir, contenir des nombres entiers, mais elle peut
également contenir des nombres à virgule, des mots comme « Bonjour », et bien d’autres choses
encore... On appelle cela des types de variables. Une variable contenant la phrase « Hello World ! »
ne sera pas du même type qu’une variable contenant la valeur approché de π : 3, 14159.
Nous n’étudierons ici que trois types :
– int : il s’agit des nombres entiers, positifs comme négatifs. Exemples : a = 123, b = -22, c = 0.
– float : ce sont des approximations de nombres réels. En effet, il n’est pas possible pour Python
de traiter les nombres réels, par exemple, pour la valeur 31 nous devrons nous contenter de valeur
approché 0, 333333333333333. Python n’offre (en standard) qu’une précision de 15 décimales.
Exemples : pi = 3.14, rien = 0.
– str : appelé chaı̂nes de caractères ce type de variable permet de traiter des mots, des phrases,
ou n’importe quelle succession de caractères. Une chaine de caractères est délimitée par des
guillemets. Exemple : phraseCulte = "Hello World !"

A faire
a = "2"
b = 3
print ( a + a )
print ( b + b )
print ( b * a )

1.7 Recopiez le programme ci-dessus dans Online-GDB et exécutez-le.

1.8 Notez et expliquez les résultats que vous obtenez.
1.2.4 Saisir des variables

Nous savons à présent comment afficher une variable, cette opération qui consiste à prendre le contenu
d’un zone mémoire et à le faire apparaı̂tre sur l’écran s’appelle, en informatique, une sortie, ou encore,
une écriture.
Nous allons voir à présent comment effectuer l’opération inverse, c’est-à-dire comment, dans un
programme, récupérer une information saisie au clavier par l’utilisateur et la placer dans une variable.
Cet type d’opération est appelé une lecture ou une entrée.
En langage Python la saisie au clavier s’effectue grâce à l’instruction input.

1 print ( " Quel est votre nom ? " ) # Invite l ’ utilisateur à entrer son nom
2 n = input () # Affecte la saisie à la variable n
3 print ( " Bonjour " , n ) # Dit bonjour à l ’ utilisateur ...

Listing 1.3 – Premier exemple d’utilisation de l’instruction input
Le code ci-dessus possède trois lignes :
– ligne 1 : Affiche un message grâce à l’instruction print afin d’inviter l’utilisateur à entrer son
nom au clavier.
– ligne 2 : L’instruction input() effectue la saisie des caractères entrés au clavier par l’utilisateur.
Lorsque l’utilisateur presse la touche Entrée la saisie se termine et la chaı̂ne de caractères qui
a été tapée est affectée à la variable n.
– ligne 3 : L’instruction print affiche le message Bonjour suivi du contenu de la variable n, c’est
à dire du nom entré par l’utilisateur.
Il est possible de confier à l’instruction input le soin d’afficher le message d’invite à l’utilisateur, en
plus d’effectuer la saisie. Cette solution est présentée dans le code ci-dessous :

1 n = input ( " Quel est votre nom ? " ) # Affiche l ’ invite et saisie la r é ponse
2 print ( " Bonjour " , n )

Listing 1.4 – Affichage et saisie avec l’instruction input
A faire
1.9 Saisissez le programme du listing 1.4 dans Online-GDB et vérifiez son bon fonctionnement.

1.2.5 Saisir des variables numériques
La fonction input lit les caractères tapés au clavier par l’utilisateur, par conséquent elle renvoie une
chaı̂ne de caractères. Il peut arriver que l’on demande à l’utilisateur d’entrer une valeur numérique
afin d’effectuer un calcul. Il faut alors changer le type de la variable renvoyée par input en un type
int ou float.
Le programme donné ci-dessous convertit en Francs un montant donné en Euros. Pour rappel, au
moment du passage du Francs à l’Euro, un Euro valait 6,55957 Francs.

1 e = input ( " Entrez le montant en Euros : " )
2 e = float ( e ) # Change le type de la variable e de str en float
3 f = e * 6.55957
4 print ( " Cela é quivaut à " ,f , " Francs " )

Listing 1.5 – Changement de type d’une variable
A faire
1.10 Saisissez le programme du listing 1.5 dans Online-GDB et vérifiez son bon fonctionnement.
1.11 Écrivez un programme qui demande à l’utilisateur d’entrer le rayon d’un cercle et qui
affiche sa surface et sa circonférence. On rappelle que pour un cercle : circonf erence =
2 × π × rayon et surf ace = π × rayon2 .
1.2.6 Synthèse
Répondez en quelques phrases aux questions suivantes :
Synthèse
1.12 Qu’est-ce qu’une variable ?
1.13 Qu’est-ce que le type d’une variable ? Quels sont les types de variables rencontrés dans ce
cours ?
1.14 Que signifie affecter une variable ? Comment se font les affectations de variables en langage
Python ?
1.15 Qu’est-ce qu’une entrée ? Qu’est-ce qu’une sortie ?
1.16 Quels sont les mots clés de Python qui permettent d’effectuer des entrées et des sorties ?
1.3 Les conditions

Un programme doit souvent prendre en compte différents cas et s’adapter à des situations. Il est alors
nécessaire d’écrire des conditions. Une condition est une expression dont le résultat est soit vrai soit
faux.
Une condition est construite à l’aide d’opérateurs de comparaison :
– l’opérateur « égal » noté « == »,
– l’opérateur « différent » noté « != »,
– l’opérateur « inférieur à » noté « < »,
– l’opérateur « supérieur à » noté « > »,
– l’opérateur « inférieur ou égal à » noté « <= »,
– l’opérateur « supérieur ou égal à » noté « >= »,

Lorsque la situation à tester est plus compliquée, il est possible de combiner plusieurs conditions
grâce aux opérateurs logiques :
– l’opérateur « and » signifie « et »
– l’opérateur « or » signifie « ou »
– l’opérateur « not » signifie « non »
Questions
On donne deux variables : a = 3 et b = 5
1.17 Indiquez, pour chacune des conditions données, si elle est vrai ou fausse :
(a) a != b
(b) a == b
(c) a != b-2
(d) a <= b
(e) not (a != b)
(f) (a != b) and (a == 3)
(g) (a != b) or (a == 3)
1.4 Les structures conditionnelles

En fonction de la valeur d’une condition (vraie ou fausse), un programme va pouvoir choisir d’exécuter
ou non un bloc d’instructions. On parle alors de structures conditionnelles.
1.4.1 La structure conditionnelle « if »

L’instruction if réalise une action lorsque une condition est vérifiée, c’est à dire lorsque son expression
est vraie.

1 t = input ( " Quelle est votre temp é rature ? " )
2 t = int ( t )
3 if t > 37:
4 print ( " Attention ! " )
5 print ( " Vous avez de la fi è vre . " )

Listing 1.6 – Exemple de structure conditionnelle if
Dans l’exemple ci-dessus, la structure conditionnelle if permet de n’exécuter les instructions print
uniquement si la valeur de la variable t est supérieure à 37.
Remarque : Les deux instructions print (lignes 4 et 5) sont décalées de quatre colonnes par rapport
à l’instruction if. Cela s’appelle une indentation c’est ce qui permet à l’interpréteur Python de savoir
que ces deux instructions font partie de la structure conditionnelle if.
A faire
1.18 Recopiez le programme dans l’éditeur de Online-GDB et exécutez-le plusieurs fois avec
différentes valeurs de température. Assurez-vous qu’il fonctionne correctement.
1.19 Retirez l’indentation du second print afin de mettre cette instruction au même niveau
que le if. Exécutez le programme plusieurs fois comme à la question précédente. Que
constatez-vous ? Expliquez ce nouveau comportement.

1.4.2 La structure conditionnelle « if-else »
La structure if-else permet d’exécuter un bloc d’instructions lorsqu’une condition est vérifiée et
un autre bloc d’instructions lorsqu’elle ne l’est pas.

1 t = input ( " Quelle est votre temp é rature ? " )
2 t = int ( t )
3 if t > 37:
4 print ( " Attention ! " )
5 print ( " Vous avez de la fi è vre . " )
6 else :
7 print ( " Tout va bien " )
8 print ( " Vous n ’ avez pas de fi è vre . " )

Listing 1.7 – Exemple de structure conditionnelle if-else
A faire
1.20 Recopiez le programme dans l’éditeur de Online-GDB et exécutez-le plusieurs fois avec
différente valeurs de température. Assurez-vous qu’il fonctionne correctement.
1.21 Comment aurait-on pu arriver au même résultat sans utiliser la structure if-else mais
uniquement la structure if ? Quel avantage la structure if-else présente-elle ?
1.4.3 Synthèse
Synthèse
1.22 Qu’est-ce qu’une condition ?
1.23 Quel est le rôle de la structure conditionnelle if ?
1.24 Quel est le rôle de la structure conditionnelle if-else ?
1.5 Les structures itératives (boucles)

Une structure itérative, plus communément appelée boucle permet de répéter un bloc d’instructions.
Il en existe deux types :
– les boucles bornées, elles sont utilisées lorsque l’on connaı̂t à l’avance le nombre de répétitions
que l’on souhaite effectuer.
– les boucles non bornées, elles sont utilisées lorsque l’on ne connaı̂t pas à l’avance le nombre
de répétitions que l’on souhaite effectuer.
1.5.1 La boucle non bornée « while »

La boucle while est toujours associée à une condition. Elle répète l’exécution d’un bloc d’instructions
tant que la condition est vérifiée (c’est-à-dire tant qu’elle est vraie).

1 codeSecret = " abcd "
2 entree = " "
3
4 while entree != codeSecret :

5 entree = input ( " Entrez le code secret : " )
6
7 print ( " Code accept é . " )

Listing 1.8 – Exemple de boucle while
Dans l’exemple ci-dessus, un code secret est enregistré dans la variable codeSecret, l’utilisateur doit
saisir un code qui sera placé dans la variable entree. Au début du programme on affecte une chaı̂ne
vide à la variable entree (ligne 2).
La ligne 5 contient une instruction input qui invite l’utilisateur à entrer un code et qui place la
chaı̂ne saisie dans la variable entree.
La boucle while de la ligne 4 va répéter l’instruction input de la ligne 5 tant que le code entré par
l’utilisateur sera différent du code secret attendu.
Puisque l’on ne peut pas connaı̂tre à l’avance le nombre de fois où l’utilisateur entrera un code erroné,
il n’est pas possible de savoir combien de fois la boucle va « tourner ».

A faire
capital = 10000 # capital de d é part
taux_interet = 3/100 # taux d ’ iteret annuel
n = 0 # nombre d ’ ann é es é coul é es
while capital < 12000: # tant que l ’ on a pas 12000 euros

interets_annuels = capital * taux_interet
capital = capital + interets_annuels
n = n + 1 # ajoute une ann é e
print (n , " ann é es " )

Le programme ci-dessus détermine en combien d’années un capital de 10000 =
C placé avec un
taux d’intérêt annuel de 3% atteint 12000 =
C.
1.25 Recopiez et exécutez le programme afin de connaı̂tre le nombre d’années nécessaire. Ob-
servez le code du programme afin d’en comprendre le fonctionnement.
1.26 Modifiez le programme pour refaire le calcul avec les paramètres suivants :
– capital de départ 15000 =
C
– capital souhaité 18000 =
C
– taux d’intérêt annuel 5.5 %
Notez le résultat obtenu.
A faire
Une feuille de nénuphar de dix centimètres de diamètre se trouve au centre d’un lac circulaire
de 10 mètres de diamètre. Le nénuphar grandit de telle sorte que le diamètre de sa feuille est
multiplié par 1,5 chaque jour.
1.27 Écrire un programme qui détermine le nombre de jours qu’il faut pour que la feuille
recouvre tout le lac.

1.5.2 La boucle bornée « for »
La boucle for indice in range(n) permet de répéter n fois le même bloc d’instruction.

for i in range (10) :
print ( i )

Listing 1.9 – Exemple de boucle for
Dans l’exemple ci-dessus la boucle for répétera 10 fois la ligne 2 : print(i). L’indice i prendra
successivement les valeurs entières comprises entre 0 et 9 (soit 10 valeurs).
A faire
La consommation énergétique annuelle d’internet était estimée à 6000 TWh/an en 2022. Elle
est multipliée par 1,2 tous les ans.
1.28 Écrire un programme qui détermine la consommation énergétique annuelle d’internet en
2030.
1.5.3 Synthèse
Synthèse
1.29 Qu’est-ce qu’une boucle ?
1.30 Qu’est-ce qu’une boucle non bornée ?
1.31 Quelle instruction Python permet de créer une boucle non bornée ?
1.32 Qu’est-ce qu’une boucle bornée ?
1.33 Quelle instruction Python permet de créer une boucle bornée ?

Chapitre 2
L’informatique embarquée
Les systèmes embarqués sont des ordinateurs et des logiciels présents dans les objets que nous utilisons
tous les jours. On retrouve des systèmes embarqués à peu près partout :
– dans les avions,
– dans les automobiles,
– dans les appareils électroménagers,
– dans la téléphonie,
– ...
2.1 La carte Galaxia

Dans la suite de ce cours nous allons utiliser la carte Galaxia pour découvrir les systèmes embarqués
et les objets connectés.
Bouton
Led RVB "Système"
Connecteur USB
Afficheur
OLED Sortie Audio Magnétomètre
Accéléromètre
Connecteur
Connecteur Groove
Groove
Touches Bouton "A"
tactiles
Haut, Bas
SOC ESP-32
Droite, Bouton "B"
Gauche
Connecteur
Micro:bit
Figure 2.1 – La carte Galaxia
Le cœur de la carte Galaxia est un System On Chip (SOC) ESP32. C’est un véritable micro-ordinateur
construit sur une seule puce. Il contient, entre autres, les éléments suivants :
– un processeur Xtensa® cadencé à 240 Mhz,
– 4 Mo de mémoire flash,
– 320 Ko de mémoire ram,
– une interface Wifi,
– une interface Bluetooth,
– une liaison usb.

Elle possède également plusieurs capteurs : Son interface utilisateur est constituée :
– un magnétomètre trois axes, – d’un écran OLED couleur,
– un accéléromètre trois axes, – d’un pavé de quatre touches tactiles,
– un capteur de température, – de deux boutons mécaniques,
– un capteur de lumière. – d’une LED RVB.
2.1.1 Le menu système

Le menu système permet de configurer la carte Galaxia. Pour y accéder, il faut appuyer sur le bouton
système.
# Menu système #
I Dernière erreur I
*| Fichier à exécuter |
I Variables I
| Boutons |
I LED I
| Capteurs |
I Redémarrer I
Figure 2.2 – Le menu système
On se déplace dans le menu à l’aide des touches directionnelles haut et bas, la ligne sélectionnée est
indiquée par une étoile sur la colonne de gauche. On valide son choix avec le bouton A.
2.2 Programmation de la carte

La carte Galaxia se programme en langage Python par l’intermédiaire d’une liason USB. Lorsqu’on
la connecte à un ordinateur, la carte est vue comme un périphérique de stockage de masse, c’est à dire
comme une clé USB. Pour la programmer il suffit copier dans dans la carte le programme Python à
exécuter, puis de le sélectionner dans le menu système.
2.2.1 Un premier programme

Vous allez à présent exécuter un programme sur la carte. Ce programme, très simple, fait clignoter
la led en rouge.

1 from thingz import led
2 import time
3
4 while True : # Boucle infinie

5 led . set_colors (255 , 0 , 0) # Allume la couleur rouge
6 time . sleep (0.5) # Attend 0 ,5 seconde
7 led . set_colors (0 , 0 , 0) # Eteint la led
8 time . sleep (0.5) # Attend 0 ,5 seconde

Listing 2.1 – Code du programme cligno.py

A faire
2.1 Connectez la carte Galaxia à l’ordinateur, vérifiez qu’elle apparait bien comme un nouveau
lecteur.
2.2 Téléchargez le fichier cligno.py sur http://prof.masi.fr et copiez-le dans la carte.
2.3 Entrez dans le menu système sélectionnez Fichier à executer, puis choisisez le fichier
cligno.py.
2.4 Vérifiez que la led de la carte clignote en rouge.
Dans la ligne de code led.set_color(255, 0, 0) les valeurs 255, 0, 0 correspondent aux niveaux
d’allumage du rouge, du vert et du bleu de la led. La valeur 255 conduit à l’allumage maximal et la
valeur 0 à l’extinction. Ainsi, led.set_color(255, 0, 0) allume la couleur rouge au maximum et
éteint le vert et le bleu.
A faire
2.5 Modifiez le programme précédent pour que la led clignote alternativement en rouge et en
vert.
2.6 Modifiez à nouveau le programme précédent pour que la led clignote rouge, verte et bleue
puis recommence. Chaque couleur restera allumée 0,5 seconde.
2.2.2 Changement de couleur progressif

On donne le programme dimmer.py ci-dessous :

2 import time
3
4 while True :
5 for i in range (256) :
6 led . set_colors (i , 0 , 255 - i )
7 time . sleep (0.01)

Listing 2.2 – Code du programme dimmer.py
Questions
2.7 Que fait la boucle for de la ligne 5 ?
2.8 Lorsque la variable i vaut 0, quelle est la couleur de la led ?
A faire
2.11 Copiez le programme dimmer.py sur la carte Galaxia et exécutez-le.
2.12 Modifiez le programme pour qu’il revienne progressivement de la couleur rouge à la couleur
bleu.

2.2.3 Acqusition des données issues de l’inclinomètre
La carte Galaxia possède plusieurs capteurs, dont un accéléromètre trois axes. Ce capteur est capable
de mesurer l’accélération due à la masse de la Terre. Nous allons l’utiliser ici comme un inclinomètre
capable de nous indiquer l’angle que forme la carte avec l’horizon.
A faire
2.13 Dans le menu système sélectionnez Capteurs.
2.14 Notez la valeur du paramètre Accel Y lorsque la carte est positionnée :
– à l’horizontale,
– à la verticale avec la led vers le haut,
– à la verticale avec la led vers le bas.
Le programme accelero.py donné ci-dessous allume la led en rouge lorsque la carte est placée led
vers le haut et l’éteint dans le cas contraire.

1 from thingz import *
2
3 while True :
4 if accelerometer . get_y () > 800: # Si l ’ acceleration est > à 800 mg
5 led . set_colors (255 , 0 , 0) # On allume la led en rouge
6 else : # Sinon
7 led . set_colors (0 , 0 , 0) # On eteint la led

Listing 2.3 – Code du programme accelero.py
Questions
2.15 Lire le code du programme et expliquer son fonctionnement.
A faire
2.16 Modifiez le programme pour que la led s’allume en rouge quand la carte est dirigée vers
le haut et en vert lorsqu’elle est dirigée vers le bas.
On donne le code du programme inclino2.py ci-dessous :

1 from thingz import *
2
3 while True :
4 i = accelerometer . get_y ()
5 rouge = int ((1000 + i ) / 4)
6 bleu = 512 - rouge
7 led . set_colors ( rouge , 0 , bleu )

Listing 2.4 – Code du programme accelero2.py

Questions
2.17 Donner les valeurs des variable rouge et bleu lorsque :
– la carte est dirigée vers le haut,
– la carte est à l’horizontale,
– la carte est dirigée vers le bas.
2.18 Que fait, à votre avis, ce programme ?
A faire
2.19 Téléchargez le programme accelero2.py et copiez-le sur la carte.
2.20 Lancez le programme et vérifiez que l’on obtient bien le résultat attendu.
2.2.4 Synthèse
Répondez, en quelques phrases, aux questions suivantes :
Synthèse
2.21 Qu’est-ce qu’un capteur ?
2.22 Quel capteur présent sur la carte Galaxia avez-vous mis en œuvre durant cette activité ?
2.23 Qu’est-ce qu’un actionneur ? Donnez deux exemples issus de systèmes techniques courants
comme une automobile ou une machine à laver.

Chapitre 3
Les objets connectés
L’informatique embarquée permet de rendre les objets communicants. Ainsi, un objet technique peut
accéder à internet et devenir un objet connecté. Cette tendance conduit à un internet des objets ou
Internet of Things (IoT).
Les applications des objets connectés sont innombrables dans l’industrie, mais également dans la vie
de tous les jours.
3.1 Mise en réseau des cartes Galaxia

La carte Galaxia est équipée d’une interface de communication Wifi. Pour la suite de cette activité
nous utiliserons un routeur Wifi auquel se connecteront les cartes mais aussi les smartphones.
Internet
Figure 3.1 – Cartes Galaxia connectées à un routeur Wifi
Afin de se connecter au routeur vous devez disposer de son SSID ainsi que du mot de passe :
– SSID : SNT
– Mot de passe : sntsainteloi
3.2 Serveur WEB embarqué

Vous allez, a présent, installer un programme permettant à la carte Galxia de devenir un serveur
web. Vous vous connecterez en suite à votre carte à l’aide d’un smartphone.

A faire
3.1 Téléchargez le programme serveur_web.py, copiez-le sur la carte Galaxia et exécutez-le.
3.2 Notez l’adresse IP qui apparait sur l’écran de la carte Galaxia.
3.3 Connectez votre smartphone au routeur wifi (le point d’accès se nommé « SNT » et le mot
de passe est « sntsainteloi ».
3.4 Entrez l’adresse IP de votre carte dans le navigateur de votre téléphone. Vérifiez que vous
arrivez à accéder au site.
On donne ci-dessous le code du programme serveur_web.py :

1 import simple_wifi
3
4 code_html = """
5 <! doctype html >
6
7 < head >

8 < meta charset =" utf -8" >
9 < title > Galaxia </ title >
10 </ head >
11
12 < body >

13
14 <h1 > La carte Galaxia </ h1 >

15
16 <h2 > Pr é sentation </ h2 >

17 <p >
18 La carte Galaxia est un carte
19 permettant de d é couvrir le monde
20 des objet connect é s . Elle se programme
21 en langage Python à partir d ’ un simple PC
22 sans avoir à utiliser de logiciel ou de
23 mat é riel d é di é .
24 </p >
25
26 <h2 > Caract é ristiques </ h2 >

27
28 <ul >
29 <li > System On Chip ESP -32 : </ li >
30 <ul >
31 <li > Processeur XTensa cadenc é à 240 Mhz </ li >
32 <li >4 Mo de m é moire Flash </ li >
33 <li >320 ko de m é moire Ram </ li >
34 <li > Connectivit é Wifi </ li >
35 <li > Connectivit é Bluetooth </ li >
36 </ ul >
37 <li > Capteurs : </ li >
38 <ul >
39 <li > Magn é tom è tre 3 axes </ li >
40 <li > Acc é l é rom è tre 3 axes </ li >
41 <li > Capteur de temp é rature </ li >
42 <li > Capteur de lumi è re </ li >
43 </ ul >

44 <li > Afficheur couleur OLED </ li >
45 <li > Led RVB </ li >
46 </ ul >
47 </ body >
48 </ html >
49 """
50
51 simpleWifi = simple_wifi . SimpleWifi ()

52 http = simple_wifi . SimpleHttp ( simpleWifi )
53
54 simpleWifi . connect ( ’ SNT ’ , ’ sntsainteloi ’)

55
56 while True :
57 http . wait_request ()
58 http . respond_with_html ( code_html , template = " mytemplate . html " )

Listing 3.1 – Code du programme serveur_web.py
Le code html de la page web qui apparait lorsque vous vous connectez à la carte est contenu dans la
variable Python html (lignes 5 à 48).
A faire
3.5 Modifiez le code html pour personnaliser votre site. Vous veillerez à faire apparaitre les
noms des élèves de l’équipe.
3.6 Relancez le programme et connectez-vous à nouveau sur votre carte. Vérifiez que vos
modifications sont bien visibles.
3.3 Une lampe connectée

Les objets connectés peuvent êtres contrôlés à distance au travers du réseau. Nous allons à présent
réaliser une lampe connectée que nous pourrons allumer ou éteindre à distance depuis un ordinateur,
une tablette ou un smartphone.
Réseau
Lampe connectée
IP : 192.168.0.5
Figure 3.2 – Exemple d’objet connecté : La lampe connectée
Le protocole http permet de demander, depuis un client, l’accès à une ressource sur le serveur. Dans
l’exemple ci-dessus, c’est le navigateur du téléphone qui est le client, et la carte Galaxia le serveur.
Lorsque l’on demandera, depuis le client, à accéder à la ressource « a » (comme Allumer), la carte
Galaxia allumera la led et lorsque l’on demandera à accéder à la ressource « e » (comme éteindre),
la Galaxia éteindra la led.
Pour demander au navigateur d’accéder à une ressource spécifique il faut ajouter /mon_ressource
après l’adresse IP. Dans l’exemple ci-dessus :
– 192.168.0.5/a allumera la led
– 192.168.0.5/e éteindra la led

On donne, ci-dessous, le code du programme lampe_connectee.py :

1 import simple_wifi
3
4 mess_html = " "

5
6 code_html_1 = """
7 <! doctype html >
8
9 < head >

10 < meta charset =" utf -8" >
11 < title > Galaxia </ title >
12 </ head >
13
14 < body >

15
16 <h1 > Lampe connect é e </ h1 >

17
18 <h2 > La lampe est

19 """
20
21 code_html_2 = """
22 </ h2 >
23 </ body >
24 </ html >
25 """
26
27 simpleWifi = simple_wifi . SimpleWifi ()

28 http = simple_wifi . SimpleHttp ( simpleWifi )
29
30 simpleWifi . connect ( ’ SNT ’ , ’ sntsainteloi ’)

31
32 while True :
33 response = http . wait_request ()
34 message = response . get_url ()
35 mess_html = ’ ’
36 if message == ’a ’:
37 led . set_colors (255 , 255 , 255)
38 mess_html = " allum é e "
39 if message == ’e ’:
40 led . set_colors (0 , 0 , 0)
41 mess_html = " etteinte "
42
43 http . respond_with_html ( code_html_1 + mess_html + code_html_2 , template

= " mytemplate . html " )

Listing 3.2 – Code du programme lampe_connectee.py
A faire
3.7 Téléchargez le programme lampe_connectee.py, copiez-le sur la carte Galaxia et exécutez-
le.
3.8 Depuis votre smartphone, essayez d’allumer et d’éteindre la led.

On souhaite à présent pouvoir piloter à distance la couleurs de la led. Pour cela on disposera des
ressources « r », « v », « b » et « w » correspondant respectivement aux couleurs rouge, vert, bleu,
et blanc.
A faire
3.9 Modifiez le programme lampe_connectee.py afin d’obtenir le comportement souhaité.
3.10 Vérifiez le fonctionnement de votre programme.
3.4 Synthèse
Répondez aux questions suivantes en quelques phrases :
Synthèse
3.11 Qu’est-ce qu’un objet connecté ? Donnez trois exemples.
3.12 Qu’est-ce que l’internet des objets ?
3.13 Quel sigle (anglais) utilise-ton pour désigner l’internet des objets ?
3.14 Quel est le protocole de communication que vous avez utilisé pour réaliser vos objets
connectés avec la carte Galaxia ?
3.15 La carte était-elle un client ou un serveur ?

Info Embarquee Objets Connectes

Transféré par

Informations du document

Titre original

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

Info Embarquee Objets Connectes

Transféré par

Droits d'auteur :

Formats disponibles

Lycée polyvalent Saint-Eloi

9 avenue Jules Isaac

Sciences Numériques et Technologie

Thème : Informatique embarquée et objets connectés

Afin de faciliter la relecture de votre travail :

Des logos vous permettront d’identifier le type de travail à effectuer :

1 La programmation en langage Python 5

3 Les objets connectés 19

Figure 1 – Architecture d’un système informatique embarqué

Informatique embarquée et objets connectés 4/23 S.N.T

La programmation en langage Python

1.1 Programmation en ligne avec Online-GDB

Figure 1.1 – Écran de GDB

Informatique embarquée et objets connectés 5/23 S.N.T

1.2 Les variables

1.2.2 Affichage des variables

Informatique embarquée et objets connectés 6/23 S.N.T

On remarque deux choses :

1.2.3 Type des variables

Informatique embarquée et objets connectés 7/23 S.N.T

1.7 Recopiez le programme ci-dessus dans Online-GDB et exécutez-le.

1.2.4 Saisir des variables

Le code ci-dessus possède trois lignes :

Informatique embarquée et objets connectés 8/23 S.N.T

1.3 Les conditions

Informatique embarquée et objets connectés 9/23 S.N.T

1.4 Les structures conditionnelles

1.4.1 La structure conditionnelle « if »

Informatique embarquée et objets connectés 10/23 S.N.T

1.5 Les structures itératives (boucles)

1.5.1 La boucle non bornée « while »

Informatique embarquée et objets connectés 11/23 S.N.T

4 while entree != codeSecret :

7 print ( " Code accept é . " )

while capital < 12000: # tant que l ’ on a pas 12000 euros

print (n , " ann é es " )

Informatique embarquée et objets connectés 12/23 S.N.T

Informatique embarquée et objets connectés 13/23 S.N.T

2.1 La carte Galaxia

Figure 2.1 – La carte Galaxia

Informatique embarquée et objets connectés 14/23 S.N.T

2.1.1 Le menu système

Figure 2.2 – Le menu système

2.2 Programmation de la carte

2.2.1 Un premier programme

4 while True : # Boucle infinie

Informatique embarquée et objets connectés 15/23 S.N.T

2.2.2 Changement de couleur progressif

Informatique embarquée et objets connectés 16/23 S.N.T

On donne le code du programme inclino2.py ci-dessous :

Informatique embarquée et objets connectés 17/23 S.N.T

Informatique embarquée et objets connectés 18/23 S.N.T

Les objets connectés

3.1 Mise en réseau des cartes Galaxia

Figure 3.1 – Cartes Galaxia connectées à un routeur Wifi

3.2 Serveur WEB embarqué

Informatique embarquée et objets connectés 19/23 S.N.T

On donne ci-dessous le code du programme serveur_web.py :

7 < head >

12 < body >

14 <h1 > La carte Galaxia </ h1 >

16 <h2 > Pr é sentation </ h2 >

26 <h2 > Caract é ristiques </ h2 >