Livret « Informatique embarquée et objets connectés » Deuxième...

Sciences Numériques et Technologie

Livret « Informatique embarquée et objets connectés »Deuxième partie : activités

Soutien aux formations assurées dans l’Académie de Rouen en novembre/décembre 2019

Préambule

Depuis la publication du Bulletin officiel spécial n°1 du 22 janvier 2019, l’enseignement de sciences numé-riques et technologie (SNT) est officiellement programmé pour la classe de seconde générale et technolo-gique dès la rentrée 2019. A destination des enseignants susceptibles d’enseigner cette nouvelle discipline,une formation de 4 journées a été prévue dans l’Académie de Rouen, répartie entre mai 2019 et dé-cembre 2019. Sous l’impulsion de plusieurs corps d’inspection, des professeurs de collèges et de lycées del’académie rouennaise se sont impliqués dans la conception de cette formation.

Ce livret regroupe une partie du contenu de cette formation. Ce document est donc destiné à des en-seignants et donne des pistes de réflexion, sans donner, pour autant, systématiquement, des activitésfournies clé en main. Ce recueil ne se veut pas être un modèle exclusif d’activités à mener avec ses élèvesmais est le fruit de travaux de professeurs, de disciplines variées, ayant réfléchi sur un thème particulier.La compilation de ces productions servira de support de travail lors des formations. Selon les sensibilités(matière d’origine, expertise dans un thème...) de chaque concepteur d’activités, les contenus sont d’uneapproche et d’un niveau différents. Le choix a été de conserver cette hétérogénéité car les enseignants,destinataires de cette formation, n’ont justement pas la même homogénéité de connaissances et ce livretespère, ainsi, satisfaire le plus grand nombre. Ce recueil conserve toutefois la perception officielle de cetenseignement : « L’enseignement de sciences numériques et technologie en classe de seconde a pour objetde permettre d’appréhender les principaux concepts des sciences numériques, mais également de permettreaux élèves, à partir d’un objet technologique, de comprendre le poids croissant du numérique et les enjeuxqui en découlent ». Il n’est donc pas question de trouver, ici, des activités expertes mais plutôt de quoienrichir la culture numérique de tous les élèves.

Dans le cadre de cet enseignement, sept thématiques sont au programme :• Internet• Le Web• Les réseaux sociaux• Les données structurées et leur traitement• Localisation, cartographie et mobilité• Informatique embarquée et objets connectés• La photographie numérique

Une thématique transversale est l’algorithmique par l’utilisation de Python. Pour plus d’informations à cesujet, le lecteur est invité à consulter le livret de formation sur Python que le pôle de compétences demathématiques de l’Académie de Rouen a créé pour les formations académiques 2018 dans le cadre desprogrammes de seconde.

Ce livret traite principalement du thème « Informatique embarquée et objets connectés » même sipar transversalité, d’autres thèmes pourront être abordés.

Ce recueil est téléchargeable sur le site académique de Rouen à l’adresse suivante :http://maths.spip.ac-rouen.fr/spip.php?article800.

Outre ce document, y sont entreposés des compléments comme des approfondissements, des corrections,des fichiers Python, une sitographie, certaines activités nationales. . . Notamment, tous les fichiers évoquésdans les activités de ce livret, suivis d’un astérisque (∗), seront téléchargeables sur le site académique deRouen à l’adresse ci-dessus.

2

https://www.education.gouv.fr/pid285/bulletin_officiel.html?cid_bo=138143

http://maths.spip.ac-rouen.fr/spip.php?rubrique149

http://maths.spip.ac-rouen.fr/spip.php?article800

Afin de faciliter l’usage de ce livret, sont listés ci-dessous, les contenus et capacités attendues dans leprogramme de SNT. Même si ce tableau est donné à titre indicatif et que ses informations sont reprises,adéquatement, dans chaque activité, il ne remplace pas le contenu explicite du programme de SNT.

Contenus Capacités attendues

Systèmes informatiques embarqués Identifier des algorithmes de contrôle des comportements phy-siques à travers les données des capteurs, l’IHM et les actions desactionneurs dans des systèmes courants.

Interface homme-machine Réaliser une IHM simple d’un objet connecté.Commande d’un actionneur, acqui-sition de données d’un capteur

Écrire des programmes simples d’acquisition de données ou decommande d’un actionneur.

Exemples d’activités

• Identifier les évolutions aportées par les algorithmes au contrôle des freins et du moteur d’uneautomobile, ou à l’assistance au pédalage d’un vélo électrique.• Réaliser une IHM pouvant piloter deux ou trois actionneurs et acquérir les données d’un ou deux

capteurs.• Gérer des entrées/sorties à travers les ports utilisés par le système.• Utiliser un tableau de correspondance entre caractères envoyés ou reçus et commandes physiques

(exemple : le moteur A est piloté à 50% de sa vitesse maximale lorsque le robot reçoit la chaîne decaractères « A50 »).

Commentaire additionnel concernant l’informatique embarquée etles objets connectés

Les rédacteurs de ce livret ont conscience :• de la diversité des sensibilités des enseignants de SNT, selon leur discipline d’origine ;• des multiples matériels, préexistants (ou non) dans les établissements, aux langages de programmation

et aux fonctionnalités très variés ;• des conditions d’enseignement variables selon les établissements.

En conséquence, le présent livret présente un éventail d’activités le plus large possible.

Ainsi, on trouvera des activités sur cartes Arduino (programmées en C++, avec ou sans l’aide de blocs),sur cartes micro:bit (Python, avec ou sans l’aide de blocs), sur le nano-ordinateur Raspberry Pi (enPython), voire, avec l’aide d’AppInventor, sur smartphone ou tablette fonctionnant sous Android (exclu-sivement). Autant que possible, des émulateurs seront présentés, pour pallier l’absence ou l’indisponibilitéd’un matériel.

En fin de livret, un tableau recense, activité par activité, le matériel en jeu et le (ou les) langage(s) deprogrammation employé(s).

Aucune activité n’est prescriptive. Nombre d’entre elles peuvent être adaptées à d’autres matériels. Unlivret d’initiation décline une même activité sur diverses cartes, de manière à pouvoir comparer les supportset langages.

Compléments en ligne

Des liens vers des sites où acheter les cartes décrites ci-dessus, vers de la documentation, sont disponiblesen ligne∗.

3

https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf

https://cache.media.education.gouv.fr/file/SP1-MEN-22-1-2019/08/5/spe641_annexe_1063085.pdf


Table des matières

Comment créer des applications Android utilisant les capteurs d’un smartphone ? 5Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

Algorithmes de contrôle de comportements physiques 9Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

Ventilateur contrôlé par la température sur Arduino 13Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Programmer une boussole sur micro :bit 17Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Un podomètre sur micro :bit 23Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Jouer à Shifumi sur micro :bit 33Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Simulation des clignotants et feux stop d’un véhicule sur Sense Hat 38Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

Simulation d’une boussole sur Sense Hat 43Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

Pilotage d’un moteur à courant continu 49Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Comment piloter un robot à distance ? 57Fiche élève . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Comment les objets connectés peuvent venir en aide aux personnes à mobilité réduite ? 62Fiche professeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Synthèse du contenu des activités 65

4

Sciences numériques et technologie

Académie de Rouen — Formations 2019Auteur : Frédérique Gonzalez d’après Stéphane Méal

(académie de Nantes)

Informatique

embarquée et

objets connectés

Comment créer des applications

Android utilisant les capteurs d’un

smartphone ?

Fiche élève

Partie A — Qu’est-ce qu’un smartphone ?

1. Lister dans le tableau suivant les services que peut rendre un smartphone.

Services sans 4G ou wifi Services avec 4G ou wifi

2. Lister dans le tableau suivant les composants principaux d’un smartphone.

Éléments visibles Éléments invisibles

3. Préciser l’utilité de la carte SIM dans un smartphone.

4. Préciser l’utilité du système d’exploitation dans un smartphone.

5

Partie B — Identifier les capteurs présents sur un smartphone

1. Lister les capteurs présents sur un smartphone.

2. Télécharger une application permettant de tester les capteurs présents sur votre smartphone (exemple :Z-Device Test).Lancer l’application et compléter la liste de la première question.

Partie C — Comment utiliser les capteurs dans une application ?

Le but de cette partie est de créer une application AppInventor utilisant la boussole d’un smartphonesous Android.

Depuis un ordinateur, se connecter à l’adresse ci-dessous, choisir l’option « Sans compte » et noter le codedu projet.

http://code.appinventor.mit.eduApp inventor est un logiciel de programmation par blocs. Il est composé de deux environnements :

• l’un permet de créer l’allure de l’application (Designer) ;• l’autre permet, par l’assemblage de blocs, de créer le comportement de l’application

(Blocs).

Pour tester une application, on peut télécharger MIT AI Companion sur le smartphone (ordinateur etsmarphone doivent pouvoir communiquer par wifi), ou compiler l’application (fichier .apk) et la chargersur le smartphone via un câble USB.

Application — Transformer le smartphone en boussole

Design de l’application

Les questions ci-après sont consacrées à la création d’une interface graphique dans l’environnement De-signer de AppInventor.

1. Télécharger sur l’ordinateur une image de rose des vents comme celle ci-dessous.

Par Simple_compass_rose.svg : Brosen, modification by Howchengderivative work : M0tty

(talk) – Simple_compass_rose.svg, CC BY 3.0,

https://commons.wikimedia.org/w/index.php?curid=16707727

6

http://code.appinventor.mit.edu

https://commons.wikimedia.org/w/index.php?curid=16707727

2. Dans AppInventor, environnement Designer, grâce au menu de droite, glisser-déposer une image dansl’interface en forme de smartphone.Dans les menus de droite, charger l’image de rose des vents, puis modifier les propriétés de l’image,comme indiqué ci-dessous.

Élément « image » à glisser

Télécharger l’image

Réglages :• dimensions• chargement du média

3. Depuis le menu de gauche, glisser-déposer un « label » (c’est une « boîte » pour afficher un texte).Dans les menus de droite, le renommer « Azimut » dans le menu composants ET dans le menu propriétés.

4. Comme ci-dessus, créer un deuxième « label » nommé « Données ».

5. Glisser-déposer le « Capteur d’orientation » que l’on trouve dans la liste « Capteurs » du menu degauche.Ce capteur est un « Composant non visible ».

Programmation de l’application

Dans l’interface Blocs, on cherche à obtenir l’algorithme ci-dessous.

Quand le capteur d’orientation détecte un changement :l’image "Rose des vents" tourne en fonction de l’azimut.afficher la valeur de l’azimut sur la boîte de texte "Données".

Fin quand

En langage AppInventor, celadonne le programme ci-contre, àcoder.

Chargement de l’application dans le smartphone

Une fois le programme terminé, cliquer sur « Construire / App », et charger le fichier .apk obtenu sur lesmartphone à l’aide d’un câble USB. Installer ensuite l’application.Dans tous les cas, sur le smartphone, l’installation d’applications tierces doit être autorisée.

7


Académie de Rouen — Formations 2019Auteur : Frédérique Gonzalez d’après Stéphane Méal

(académie de Nantes)

Informatique

embarquée et

objets connectés

Comment créer des applications

Android utilisant les capteurs d’un

smartphone ?

Fiche professeur

Contenus et capacités


Interface homme-machine (IHM) Réaliser une IHM simple d’un objet connecté.

Commande d’un actionneur, acquisitiondes données d’un capteur

Écrire des programmes simples d’acquisition de données oude commande d’un actionneur.

Modalités

Durée : 1h à 1h 30.

Les parties A et B peuvent être réalisées sans ordinateur, seuls sont nécessaires les smartphones des élèvespour la partie B.

La partie C nécessite un ordinateur connecté à Internet, et des smartphones ou tablettes sous Android ; ànoter que les iPhones ne sont pas compatibles avec AppInventor.

Descriptif

Le but de l’activité est de découvrir ce que peut faire un smartphone, objet que la plupart des élèves onten poche.

Les parties A et B permettent de découvrir les fonctionnalités du smartphone, ses composants physiques,et en particulier les capteurs.

La partie C montre comment, avec AppInventor, exploiter soi-même les données fournies par les capteurs.

Logiciels et applications utilisés

• AppInventor : http://code.appinventor.mit.edu (bien noter le code de projet).• Z-device Test : à installer sur smartphone ou tablette Android à partir du Google Store.• AI Companion : à installer sur smartphone ou tablette Android à partir du Google Store.

Variantes possibles

Voir la programmation d’une boussole sur micro:bit en blocs, Javascript ou Python, dans Programmerune boussole sur micro:bit.

Voir la programmation en Python d’une boussole sur Raspberry Pi et Sense Hat dans Simulation d’uneboussole sur Sense Hat.

8



Académie de Rouen — Formations 2019Auteur : Laurent Cournil

Informatique

embarquée et

objets connectés

Algorithmes de contrôle de compor-

tements physiques

Fiche élève

Partie A — Ventilateur contrôlé par la lumière

Un dispositif embarqué est décrit ci-contre.• Dans l’unité de traitement, la quantité de lumière

reçue est traduite par une variable N, et la vitessede rotation du moteur par une variable P.• L’unité de traitement dispose des intructions sui-

vantes :Mettre valeur capteur dans ...

Transmettre ... au moteurAttendre ... secondes

• L’unité de traitement travaille en permanence,comme dans la boucle Répéter indéfinimentde Scratch.

Capteur de lumièreMesure la quantité de lumière reçue.La transforme en un entier entre 0 et 1023.

↓Unité de traitementTransfère les informations reçues du capteurvers le moteur, en suivant un programmeou algorithme.

↓MoteurTransforme l’énergie électrique en un mou-vement circulaire.La vitesse de rotation est proportionnelle àun entier entre 0 et 255.

1. À l’aide du graphique ci-contre, établir la formule qui,à toute quantité N émise par le capteur, associe unevitesse P transmise au moteur.Tester le résultat en remplissant le tableau.

2. Rédiger l’algorithme que doit appliquer l’unité de trai-tement, de sorte qu’à chaque demi-seconde, la vitessesoit adaptée à la quantité de lumière reçue.

100

200

250 500 750 1000

1023

255

P

N

N 0 255 511 1023

P 0 255

9

Partie B — Logigramme d’un système embarqué : régulateur devitesseIl est possible de résumer le fonctionnement du système cap-teur de lumière / ventilateur de la partie A par le logigrammeci-contre.

La flèche qui revient au début signifie qu’il s’agit d’une bouclesans fin : le système fonctionne en permanence.

Légende

Échange avec l’extérieur : en-trée / sortie de données

Instruction simple

Sous-programme

Si ...

Vrai

Faux Test de type if / else

Début

Affecter à N la valeurdu capteur

Conversion de N en P

Transfert de P aumoteur

Modélisation d’un régulateur de vitesse

Un régulateur de vitesse a pour but de maintenir un véhicule à une vitesse constante V, à une erreur près ;disons à 1 km/h près, V étant exprimée dans cette même unité.

Le régulateur dispose de trois informations :• la vitesse réelle Vr du véhicule, issue de capteurs situés sur les axes des roues ;• la consigne de vitesse V, issue du tableau de bord ;• une information « interruption de service » S ne prenant que deux valeurs (vrai ou faux) : cette in-

terruption de service peut être provoquée par un débrayage, un coup de frein, un choc, un arrêt durégulateur par le conducteur. . .

Il dispose aussi de deux sous-programmes pour accélérer et ralentir.L’amorce d’un logigramme modélisant le fonctionnement du régulateur est représentée page suivante.Compléter ce logigramme avec les éléments proposés ci-dessous.

Lire S Si S = Vrai

Vrai

Faux

Ralentir Fin

10

Début

Lire la vitesse Vr

Lire la vitesse V

Si Vr < V−1

Accélérer Si ............

Vrai

Faux

Vrai

Faux

11



Informatique

embarquée et

objets connectés

Algorithmes de contrôle de compor-

tements physiques

Fiche professeur



Systèmes informatiques embarqués Identifier des algorithmes de contrôle des comportementsphysiques à travers les données des capteurs, l’IHM et lesactions des actionneurs dans des systèmes courants.

Modalités

Une heure au plus, classe entière, en mode débranché.

Descriptif

L’objectif de l’activité est d’analyser la transmission d’information d’un point de vue purement théoriquedans deux systèmes embarqués : l’un autonome, l’autre avec une IHM.Deux aspects sont privilégiés :• les logigrammes (ou algorigrammes, organigrammes. . .) ont pour but d’illustrer de façon synthétique

les algorithmes de fonctionnement des systèmes ;• dans la partie A, le transfert de l’information reçue (tension aux bornes d’une photorésistance) au

moteur nécessite un « mappage », ici présenté de façon purement théorique, sans tenir compte descontraintes des objets réels.

Pour une partie A plus « réelle »

En réalité, le capteur ne fournit pas directement le nombre N, mais une tension comprise entre 0 et 5V selonla luminosité captée. Le convertisseur analogique-numérique (« l’unité de traitement ») élabore ensuite unnombre N à partir de cette tension. Ce nombre N varie entre 0 pour 0V et 1023 pour 5V.

La vitesse du moteur est très approximativement proportionnelle à la valeur moyenne de la tension quil’alimente. Cette valeur moyenne est obtenue en alimentant et en éteignant très rapidement le moteur,comme si on le faisait clignoter.Le rapport entre le temps d’allumage et la période du signal s’appelle le rapport cyclique et se note δ. Cerapport cyclique δ peut varier entre 0% (aucun allumage) et 100% (allumage constant).En informatique, ce rapport cyclique devient un entier P et est codé sur 8 bits, ce qui permet de représenterles entiers entre 0 et 255.En conclusion, comme le moteur est alimenté en tension continue 5V au maximum, la tension moyenne

d’alimentation est définie par la relation : Vmoy = δ × 5 =P

255× 5.

L’activité Ventilateur contrôlé par la température sur Arduino intègre un travail sur cette conversionanalogique-numérique, et sur une fonction de transfert plus réaliste.

12


Académie de Rouen — Formations 2019Auteur : Gwendal Jugand

Informatique

embarquée et

objets connectés

Ventilateur contrôlé par la tempéra-

ture sur Arduino

Fiche élève

Cahier des charges

La rotation d’un moteur doit être proportionnelle à la température ambiante.

Partie A — Capteur de température et convertisseur analogique-numérique

On dispose d’un capteur de température TMP36 qui fournit une tension proportionnelle à la température.

1. Ouvrir un navigateur à la page https://www.tinkercad.com ; se connecter avec les identifiants fournispar le professeur.

Câbler alors le montage ci-dessous.

Le capteur est relié à l’entrée analogique A0 qui est une entrée spécifique du micro-contrôleurArduino. Cette entrée :

• prend en entrée une tension comprise entre 0 et 5 V ;• produit en sortie un nombre compris entre 0 pour 0V et 1023 pour 5V.

On dit que c’est un Convertisseur Analogique Numérique ou « CAN ».

13

https://www.tinkercad.com

Le moniteur série permet d’afficher les valeurs de ce nombre pour différentes valeurs de la température ;suivre pour cela les étapes ci-dessous.

Fenêtre de code

Démarrer la simulation

Ouvrir le moniteur série (enbas à droite)

Manipuler le curseur sur lecapteur de température

2. Relever les valeurs extrêmes de la température,et du nombre correspondant via le CAN.

Min Max

Température (o C)

Numérisation : N

Partie B — Pilotage du ventilateur

1. Câbler le montage ci-contre.

Un moteur DC est branché sur une broche spéciale du micro-contrôleur, la broche 3 portant lesymbole ∼.

Il s’agit d’une sortie à Modulation de Largeur d’Impulsion (MLI) ou Pulse Width Modulation (PWM),qui permet de faire varier la tension moyenne du moteur et donc sa vitesse.

Cette vitesse est « contrôlable » par le bloc ci-contre, présenté en2 versions : valeur de la vitesse au minimum (0) et au maximum(255).

14

2. Adaptation des deux signaux

• En entrée, l’information traduisant la température est un nombre variant de Nmin à Nmax (voirpartie A).• En sortie, le pilotage du ventilateur se fait via un nombre variant de 0 à 255.

Cela se traduit par la fonction de transfert représentée ci-dessous.Cette fonction donne la vitesse en fonction du nombre traduisant la température.Justifier son expression.

50

100

150

200

250

50 100 150 200 250 300 350

f(x) ≈ 0.754x− 15.1

b

b

3. Terminer le codage du pilotage du ventilateur, à l’aidedes blocs ci-contre.Tester le résultat en lançant la simulation et en ma-nipulant le curseur de température.

15


Académie de Rouen — Formations 2019Auteur : Gwendal Jugand

Informatique

embarquée et

objets connectés

Ventilateur contrôlé par la tempéra-

ture sur Arduino

Fiche professeur






Modalités

En demi-classe, individuellement avec ordinateur connecté à Internet ; durée : 1 heure.Il faut avoir préparé un groupe classe sur Tinkercad et avoir récupéré les identifiants pour chaque élève.Ainsi, la simulation pourra être réalisée individuellement, et sera visible par le professeur.

Descriptif

Premier objectif : réalisation d’un montage simple sous Tinkercad constitué d’un Arduino, d’un capteurde température et d’un moteur à courant continu.

Deuxième objectif : les élèves doivent construire le code sous forme de blocs permettant d’obtenir lavaleur N issue d’un CAN (Convertisseur Analogique Numérique) sur la console série. Cette valeur est le« reflet numérique » de la tension présente en sortie du capteur de température.Ensuite, il leur faut déterminer, par expérimentation, les valeurs extrêmes de cette valeur N en fonctiondes conditions de température.

Troisième objectif : à partir des valeurs de N et de celles du rapport cyclique P comprises entre 0 et 255,on fournit aux élèves la fonction de transfert entre N et P, c’est-à-dire la vitesse de rotation du moteur enfonction de la température. Une expression de la fonction, donnée, doit être justifiée par calcul.

À partir de cette fonction de transfert, les élèves doivent « dessiner » l’algorithme permettant de modifierla vitesse du moteur en fonction de la température.

Quatrième objectif : il ne reste plus qu’à expérimenter la maquette numérique complète en vérifiantque le cahier des charges est bien respecté.

Pour aller plus loin

Il est possible de limiter la plage de température à des valeurs « humaines »entre 18 et 40o C par exemple. Il faudra reconstruire la fonction de trans-fert et retrouver son expression. Il faudra aussi « gérer » les valeurs detempérature hors limite avec des conditionnelles comme ci-contre.

Si T > 40Alors N = 40

Si T < 25Alors N = 25

16

https://www.tinkercad.com


Académie de Rouen — Formations 2019Auteur : Thomas Goubin

Informatique

embarquée et

objets connectés

Manipulation d’une image 5×5

Programmer une boussole sur

micro:bit

Fiche élève

Présentation du micro:bit et de l’objectif

La carte micro:bit est un petit ordinateur, dont voici la description.

Capteur de température inté-gré au processeur

Boussole (compass)

Capteurs de mouvements(accéléromètre)

25 LEDs

Broches de connexion (pins)

Bouton de réinitialisation

Port USB

Connecteur batterie

Boutons A et B

La partie du micro:bit qui interprète et exécute les instructions est : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Le micro-bit peut être alimenté par un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .ou par . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Objectif

L’objectif de cette activité est de transformer le micro:bit en boussole : la matrice de LEDs devra afficheren permanence la direction du Nord magnétique.

Compléter le tableau ci-dessous avec les éléments de la carte nécessaires à cette application.

Capteur (acquérir) Actionneur (communiquer)

17

Partie A — Définir les intervalles pour chaque point cardinal

Position du zéro de laboussole intégrée à la carte

Sens de la mesure effectuéepar le capteur

NordN-E

Est

S-ESud

S-O

Ouest

N-O

0o

270o

180o

90o

2

3

4

6

7

8 10

11

12

14

15

16

On souhaite diviser la mesure effectuée avec la boussole en8 parties égales :

Nord, Nord-Est, Est, Sud-Est,Sud, Sud-Ouest, Ouest et Nord-Ouest.

Pour cela, le cercle azimutal est divisé en 16 pour obtenirles bornes de chaque intervalle.

Compléter le tableau de correspondance ci-dessous.

Numéro sur le cercle 2 4 6 8 10 12 14 16

Valeur (degrés)

Partie B — Définir les matrices de LEDs pour chaque affichageet chaque langage

Il existe pour le micro:bit plusieurs langages de programmation : par blocs (ici sera utilisé MakeCode,à l’adresse https://makecode.microbit.org), textuel (Javascript avec MakeCode, microPython avec MuEditor). . .

Ouvrir un navigateur Internet et aller sur la page :https://makecode.microbit.org

Ouvrir un nouveau projet. Le bloc pilotant la matrice deLEDs est dans le menu Base.

Dans tous les cas, le programme écritpour micro:bit doit être compilé puis té-léversé sur la carte via un câble USB.Cela peut être réalisé depuis l’éditeur, ouen téléchargeant le programme et en letransférant à la main.

On peut traduire les blocs en langage Javascript grâce au commutateur :

Cette traduction automatique permet de compléter les colonnes « En blocs » et « En Javascript » dutableau ci-après.

18

https://makecode.microbit.org

https://codewith.mu


Compléter le tableau ci-dessous pour chaque direction et chaque langage.

Remarque : en Python, pour une LED de micro:bit, 9 signifie intensité maximum et 0 signifie éteint.

Direction En blocs En Javascript En Python

Haut

basic.showLeds(‘. . # . .. # # # .# . # . #. . # . .. . # . .‘)

H = Image("00900:""09990:""90909:""00900:""00900")

Haut-gauche

basic.showLeds(‘

‘)

HG = Image(" :"" :"" :"" :"" ")

Gauche

basic.showLeds(‘

‘)

G = Image(" :"" :"" :"" :"" ")

Bas-gauche

basic.showLeds(‘

‘)

BG = Image(" :"" :"" :"" :"" ")

Bas

basic.showLeds(‘

‘)

B = Image(" :"" :"" :"" :"" ")

19

Bas-droite

basic.showLeds(‘

‘)

BD = Image(" :"" :"" :"" :"" ")

Droite

basic.showLeds(‘

‘)

D = Image(" :"" :"" :"" :"" ")

Haut-droite

basic.showLeds(‘

‘)

HD = Image(" :"" :"" :"" :"" ")

Partie C — Définir les conditions d’affichage de chaque image

Le compas du micro:bit renvoie la direction de la carte par rapport auNord magnétique, en degrés (de 0 à 360), dans le sens horaire.

Compléter les conditions d’affichage des différentes flèches dans le tableauci-dessous.

Image à afficher HG G BG B

Valeur renvoyéepar le compas

Minimum 22,5

Maximum 67,5

Image à afficher BD D HD H

Valeur renvoyéepar le compas

MinimumAutre

Maximum

N

Angle renvoyé par lecompas : 135 degrés.

20

Partie D — Codage dans l’un des trois langages

Ci-dessous est codé l’affichage d’une flèche, dans chacun des trois langages : blocs, Javascript et Python.Il s’agit de l’affichage de la flèche G, correspondant à un angle entre le Nord et la carte autour de 90degrés, soit compris entre 67,5 et 112,5 degrés.Noter que ce code est seulement une partie d’une structure conditionnelle (un sinon si), et que le toutdoit être dans une boucle sans fin.

Coder l’ensemble du programme de la boussole, dans un des trois langages au choix.Téléverser le programme dans la carte micro:bit, calibrer la carte (voir encadré en bas de page), et testerle résultat.

En blocs avec MakeCode

Lien vers l’éditeur en ligne : https://makecode.microbit.org

En Javascript avec MakeCode

else if (input.compassHeading() >= 67.5 && input.compassHeading() < 112.5) {basic.showLeds(‘

. . # . .

. # . . .# # # # #. # . . .. . # . .‘)

}

En Python avec Mu Editor

Lien vers l’éditeur en ligne : https://codewith.mu

elif compass.heading() >= 67.5 and compass.heading() < 112.5:display.show(G)

Calibrage de la carte micro:bitAprès avoir chargé le programme .hex sur la carte, celle-ci affiche un texte : « TILT TO FILL SCREEN »,suivi d’un point lumineux clignotant. Il s’agit d’une séquence destinée à calibrer le compas.Il faut alors remuer la carte micro:bit dans tous les sens jusqu’à ce que les points lumineux remplissentla matrice de LEDs.Une fois cette opération réalisée, le programme de la boussole se lance. Il faut renouveler le calibrage àchaque chargement d’un nouveau fichier .hex.Pour plus de détails :https://support.microbit.org/support/solutions/articles/19000008874-calibrating-the-micro-bit-compass

21


https://codewith.mu

https://support.microbit.org/support/solutions/articles/19000008874-calibrating-the-micro-bit-compass


Académie de Rouen — Formations 2019Auteur : Thomas Goubin

Informatique

embarquée et

objets connectés

Manipulation d’une image 5×5

Programmer une boussole sur

micro:bit

Fiche professeur





Interface homme-machine Réaliser une IHM simple d’un objet connecté.

Modalités

Parties A, B et C : 1h classe entière en mode débranché.Durée estimée selon les parties :• partie A — Définir les intervalles pour chaque point cardinal : 20 minutes ;• partie B — Définir les matrices de LEDs pour chaque affichage et chaque langage : 20 minutes ;• partie C — Définir les conditions d’affichage de chaque image : 15 minutes.

Partie D — Codage dans l’un des trois langages : 1h en demi-classe sur postes informatiques, en binômeou seul selon le contexte.

Descriptif

Au travers de la programmation d’une boussole avec la carte micro:bit, les notions suivantes sont décou-vertes ou travaillées :• se servir de la matrice de LEDs comme d’une IHM ;• gestion d’événements : capteur magnétomètre (compass) ;• la programmation par blocs réinvestit en partie ce qu’ont vu les élèves en collège sur Scratch.

Éléments de correction

Des éléments de correction sont disponibles en ligne∗.

Variantes possibles

Voir la même activité sur Raspberry Pi et Sense Hat dans Simulation d’une boussole sur Sense Hat.

Voir également, sur Appinventor, un programme plus élémentaire d’une boussole sur smartphone dansComment créer des applications Android utilisant les capteurs d’un smartphone ?

22


Académie de Rouen — Formations 2019Auteur : Manuel Lemesle

Informatique

embarquée et

objets connectés

Un podomètre sur micro:bit Fiche élève

Partie A — Découverte de la carte micro:bit

En exploitant le Document ressource numéro 1, répondre aux deux questions suivantes.1. Compléter le tableau ci-dessous afin de classifier les 5 dispositifs suivants de la carte micro:bit :• Matrice d’affichage 5×5 LEDs• Boutons poussoirs A et B• Bouton Reset• Accéléromètre• Magnétomètre

Capteur Actionneur

Capteur de température (non indiqué sur le Docu-ment ressource numéro 1)Capteur de lumière (non indiqué sur le Documentressource numéro 1)

2. Préciser, parmi les dispositifs du tableau ci-dessus, ceux permettant de réaliser une IHM entre unutilisateur et la carte micro:bit.

23

Partie B — Programmation de la carte micro:bit

a) « Hello World ! »Brancher la carte micro:bit au PC à l’aide d’uncâble USB.Lancer l’éditeur Mu, puis sélectionner l’outilde développement BBC micro:bit dans l’ongletMode.

Créer un nouveau fichier, puis l’enregistrer sousle nom TP1.py dans votre répertoire de travail.

Dans la zone d’édition de l’éditeur Mu, taper le code suivant :

from microbit import * ←−

ß

Permet de récupérer tout le contenu de la biblio-thèque microbit

display.scroll("Hello World !") ←−

ß

Permet de faire défiler la chaîne de caractères « HelloWorld ! » sur la matrice de LEDs

Cliquer sur « Vérifier » pour tester la syntaxedu code Python et obtenir le message de véri-fication.

Cliquer sur « Flasher » pour transférer le code Python sur la carte micro:bit et vérifier le bon fonctionnementdu programme. Pendant le transfert du programme, la LED située à côté du connecteur USB doit clignoter.

Processeur LED Reset

Il est possible de créer une boucle sans fin à l’aide de la structure algorithmique ci-dessous.

from microbit import *while True:

display.scroll("Hello World !")

Modifier le programme et le tester sur la carte micro:bit de façon à afficher indéfiniment le message devotre choix sur la matrice de LEDs.

24

https://codewith.mu

b) Battements de cœur

A partir des informations disponibles sur le Document ressource numéro 2, réaliser et tester un programmepermettant d’afficher indéfiniment sur la matrice de LEDs l’image d’un cœur pendant 500 ms puis l’imaged’un petit cœur pendant 500 ms.

c) Happy and sad

Il y a deux boutons A et B disponibles sur la carte micro:bit. La fonction button_a.is_pressed renvoieTrue ou False suivant l’état du bouton poussoir A. Cette instruction existe également pour le bouton B.Compléter puis tester le programme ci-dessous, de façon à afficher indéfiniment sur la matrice de LEDs :• une image HAPPY si A est appuyé ;• une image SAD si B est appuyé ;• rien du tout si aucun bouton n’est appuyé.

from microbit import *while True:

if button_a.is_pressed(): # Détection d’un appui sur le BP A.................. # Affichage du HAPPY

elif .................. # Détection d’un appui sur le BP B.................. # Affichage du SAD

else : # Sinon.................. # Effacement de la matrice

Partie C — Réalisation d’un podomètre avec la carte micro:bit

Cahier des charges

On se propose de réaliser, à l’aide d’une carte micro:bit, un podomètre permettant la mesure et l’affichagede deux paramètres : le nombre de pas et la distance parcourue lors d’une activité de marche.

a) Mesure et affichage du nombre de pas

Parmi les capteurs disponibles sur la carte micro:bit, indiquer celui permettant la détection d’un pas.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

À partir des informations disponibles sur le Document ressource numéro 3 :• Indiquer ci-dessous le nom du « geste courant » de la carte micro:bit permettant de détecter un pas.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

• Compléter puis tester le programme ci-dessous permettant de mesurer le nombre de pas et de l’affichersur la matrice de LEDs lorsque l’utilisateur appuie sur le bouton poussoir A.

from microbit import *nombre_de_pas = ........ # Initialisation du nombre de pas

while True:if accelerometer.was_gesture("......."): # Détection d’un pas

nombre_de_pas = nombre_de_pas + ... # Incrémentation du nombre de pas

if button_a.is_pressed(): # Détection d’un appui sur le BP Adisplay.scroll(......) # Affichage du nombre de pas

Débrancher la carte micro:bit du PC, puis réaliser le montage ci-dessous afin de tester le podomètre dansdes conditions réelles d’utilisation.

25

1 coupleur 2 piles AAAconnecté sur l’alimen-tation 3V

Tester le podomètre en le fixant sur différentes parties de votre corps (à l’aide d’un élastique par exemple)afin de déterminer la fixation la plus adaptée à une bonne sensibilité du podomètre. Le cas échéant,modifier le programme de façon à afficher le bon nombre de pas réalisés.

b) Mesure et affichage de la distance parcourue

On souhaite maintenant faire évoluer le cahier des charges précédent de façon à ce que le podomètrepuisse calculer la distance parcourue par l’utilisateur et l’afficher lorsque ce dernier appuie sur le bouton B.

Afin de calculer approximativement la distance parcourue par le marcheur, le podomètre doit connaîtrel’amplitude du pas de l’utilisateur. Elle sera mémorisée à travers la variable longueur_d_un_pas dans leprogramme du podomètre. Estimer, à l’aide d’un mètre, l’amplitude de votre pas et la reporter ci-dessous :

longueur_d_un_pas =

Indiquer ci-dessous la formule qui servira à calculer, dans le programme, la distance parcourue (représentéepar la variable distance_parcourue) en fonction des variables longueur_d_un_pas et nombre_de_pas.

distance_parcourue =

Compléter puis tester le programme ci-dessous afin qu’il réponde à ce nouveau cahier des charges.

from microbit import *longueur_d_un_pas = .... # Longueur d’un pas en mètrenombre_de_pas = .... # Initialisation du nombre de pasdistance_parcourue = ......... # Initialisation de la distance parcourue

while True:

if accelerometer.was_gesture("......."): # Détection du pasnombre_de_pas = nombre_de_pas + ... # Incrémentation du nombre de pas

if button_a.is_pressed(): # Détection d’un appui sur le BP Adisplay.scroll(........) # Affichage du nombre de pas

if button_b.is_pressed(): # Détection d’un appui sur le BP Bdistance_parcourue = ........ # Calcul distancedisplay.scroll(........) # Affichage distance

26

Partie D — Améliorations des fonctionnalités du podomètre

a) Réinitialisation du nombre de pas

On souhaite maintenant que le marcheur puisse, au cours de l’utilisation du podomètre, réinitialiser à zérole nombre de pas en appuyant simultanément sur les boutons poussoirs A et B. Afin de valider la remiseà zéro, la matrice de LEDs devra également afficher le message « INIT ».

Faire évoluer le programme précédent de façon à ce qu’il réponde à ce nouveau cahier des charges.

Rappel : l’opérateur logique ET s’écrit and en langage Python.

b) Affichage des objectifs

En plus de toutes les fonctionnalités précédentes, on souhaite maintenant que le podomètre affiche desimages différentes suivant le nombre de pas réalisés par l’utilisateur (voir tableau ci-dessous).

Nombre de pas réalisés Image sur le podomètre

Nombre de pas ≤ 10 SAD

10 < Nombre de pas ≤ 20 SMILE

20 < Nombre de pas HAPPY

Afin de répondre à cette ultime amélioration, il est possible d’implémenter dans le programme principalprécédent une fonction se nommant objectif et possédant comme unique paramètre nombre_de_pas.

Cette fonction renverra une variable nommée message correspondant à l’image à afficher en fonction dunombre de pas réalisés par l’utilisateur.

Exemple : objectif(17) renverra la variable message contenant Image.SMILE.

def objectif (nombre_de_pas):.......return message

À compléter.

Mettre en œuvre cette fonction en complétant la fin du programme principal par :

image = objectif(nombre_de_pas)display.show(image)

27

Partie E — Documents ressources

Document ressource numéro 1

Quelques rappels de technologie

Capteur Dispositif permettant de mesurer et transformer une grandeur physique (température,son, lumière, accélération. . .) en une grandeur électrique exploitable par un système.

Actionneur Dispositif permettant de transformer un signal électrique généré par un système enune grandeur physique (son, lumière, mouvement. . .).

InterfaceHomme-Machine(IHM)

Ensemble de dispositifs permettant à l’homme et à la machine de communiquer entreeux.

Constitution de la carte micro:bit

28


La fonction sleep permet d’effectuer une pause d’un temps, en millisecondes, passé en paramètre.

Exemple : sleep(10) effectue une pause de 10 ms.

La fonction display.clear permet d’effacer la matrice de LEDs.

Cette fonction n’a pas de paramètre, elle s’écrit : display.clear()

La fonction display.show permet d’afficher, sur la matrice de LEDs, une information passée en para-mètre ; ce peut être un caractère, un réel, une image, un entier ou une chaîne de caractères.

Exemple : display.show("Hello world !")

Les images prédéfinies ci-dessous peuvent être affichées sur la matrice de LEDs à l’aide de la fonctiondisplay.show.

Exemple d’utilisation : display.show(Image.HAPPY)

Image.HEARTImage.HEART_SMALLImage.HAPPYImage.SMILEImage.SADImage.CONFUSEDImage.ANGRYImage.ASLEEPImage.SURPRISEDImage.SILLYImage.FABULOUSImage.MEHImage.YESImage.NOImage.CLOCK12, Image.CLOCK11,Image.CLOCK10, Image.CLOCK9,Image.CLOCK8, Image.CLOCK7,Image.CLOCK6, Image.CLOCK5,Image.CLOCK4, Image.CLOCK3,Image.CLOCK2, Image.CLOCK1Image.ARROW_N, Image.ARROW_NE,Image.ARROW_E, Image.ARROW_SE,Image.ARROW_S, Image.ARROW_SW,Image.ARROW_W, Image.ARROW_NW

Image.TRIANGLEImage.TRIANGLE_LEFTImage.CHESSBOARDImage.DIAMONDImage.DIAMOND_SMALLImage.SQUAREImage.SQUARE_SMALLImage.RABBITImage.COWImage.MUSIC_CROTCHETImage.MUSIC_QUAVERImage.MUSIC_QUAVERSImage.PITCHFORKImage.XMASImage.PACMANImage.TARGETImage.TSHIRTImage.ROLLERSKATEImage.DUCKImage.HOUSEImage.TORTOISEImage.BUTTERFLYImage.STICKFIGUREImage.GHOSTImage.SWORDImage.GIRAFFEImage.SKULLImage.UMBRELLAImage.SNAKE

29


La carte micro:bit est munie d’un accéléromètre. Il mesure lemouvement selon trois axes :• X - l’inclinaison de gauche à droite ;• Y - l’inclinaison d’avant en arrière ;• Z - le mouvement haut et bas.

Il y a une instruction pour chaque axe :accelerometer.get_x() accelerometer.get_y() accelerometer.get_z()

Chacune renvoie un nombre positif ou négatif indiquant une mesure en milli-g.

Lorsque le nombre renvoyé est 0, l’axe de la carte dont on mesure l’accélération est perpendiculaire auchamp de pesanteur.

D’autres instructions peuvent être mises en œuvre avec l’accéléromètre :• accelerometer.current_gesture() renvoie, sous forme de chaîne de caractères, le nom des « gestes »

courants de la carte micro:bit parmi :

"up", "down", "left", "right", "face up", "face down","freefall", "3g", "6g", "8g", "shake"

• accelerometer.is_gesture(name) renvoie True ou False si le nom (paramètre name) d’un gestecourant est actif.

• accelerometer.was_gesture(name) renvoie True ou False si le nom (paramètre name) d’un gestecourant a été actif depuis le dernier appel de cette fonction.

30



Informatique

embarquée et

objets connectés

Un podomètre sur micro:bit Fiche professeur






L’objectif de cette activité est de réaliser un système informatique embarqué très simple : un podomètre.

Modalités

Environ 2 h, travail individuel en demi-classe devant ordinateur, possibilité de travailler en binôme.

Il est possible de scinder cette activité en deux parties de façon à faire un travail préparatoire en classeentière avant de passer aux activités pratiques en demi-classe. En prérequis, l’enseignant de mathématiquesdoit avoir abordé Python.

Concernant l’évaluation, il est possible de ramasser et noter le compte-rendu. Cependant, il peut être plusefficace de noter à « la volée » durant l’activité, en fixant au préalable des points d’étapes aux élèves afinde faire le bilan ensemble.

Descriptif

L’activité pratique est classique dans son découpage : la partie A traite des aspects matériels de lacarte électronique à programmer, les trois parties suivantes concernent l’écriture de programmes simplesd’acquisitions de données et de commandes d’actionneurs.

Partie A — Découverte de la carte micro:bit

Petite révision en s’appuyant sur les connaissances de l’objectif « Écrire, mettre au point et exécuter unprogramme » du cycle 4 de technologie au collège. Les élèves identifient physiquement les capteurs etactionneurs de la carte micro:bit.

Partie B — Programmation de la carte micro:bit

Prise en main de l’environnement de développement (IDE) et mise en œuvre des capteurs, actionneurs etalgorithmes permettant la réalisation du podomètre.

31

Partie C — Réalisation d’un podomètre avec la carte micro:bit

Comme la partie précédente, c’est très guidé. Idéalement, la majorité des élèves doit atteindre cette partie.

Dans un premier temps, les élèves vont tester le podomètre en le secouant à la main pour simuler un paset ils vont surement arriver à la relation :

nombre_de_pas = nombre_de_pas + 1Comme la position du podomètre avec la meilleure sensibilité se situe sur la cheville de l’utilisateur, ilfaudra amener les élèves à faire évoluer la relation vers :

nombre_de_pas = nombre_de_pas + 2.On pourra également discuter sur l’erreur réalisée en fonction de la jambe de départ. . .

Partie D — Améliorations des fonctionnalités du podomètre

Pour les plus rapides, donc c’est un peu moins guidé.

Matériel et logiciel utilisés

• La carte micro:bit utilisée dans cette activité pratique est celle-ci, avec accessoires :

https://www.gotronic.fr/art-kit-de-demarrage-micro-bit-go-set-26912.htm

Suivant l’ergonomie du poste informatique utilisé, il sera peut-être nécessaire d’acheter un câble micro-USB un peu plus long.

La carte micro:bit est équipée nativement de capteurs, actionneurs, et moyens de communicationpermettant de développer simplement (en limitant le câblage notamment) des applications avec lesélèves (https://microbit.org/fr/guide/).

• Élastiques et mètre déroulant.

• La carte micro:bit se programme dans cette activité en MicroPython :

https://microbit-micropython.readthedocs.io/fr/latest/tutorials/introduction.html

L’IDE Mu est téléchargeable ici : https://codewith.muCet IDE permet notamment de faire du Python traditionnel et de « flasher » (transférer des fichiersvers) de nombreuses cartes électroniques très facilement.

Pour les installations informatiques sous Windows, il sera peut-être nécessaire de télécharger et d’ins-taller le driver mbedWinSerial_16466.exe, afin que la carte micro:bit soit correctement reconnue.Lien de téléchargement :https://os.mbed.com/handbook/Windows-serial-configuration#1-download-the-mbed-windows-serial-port

32

https://www.gotronic.fr/art-kit-de-demarrage-micro-bit-go-set-26912.htm

https://microbit.org/fr/guide/

https://microbit-micropython.readthedocs.io/fr/latest/tutorials/introduction.html

https://codewith.mu

https://os.mbed.com/handbook/Windows-serial-configuration#1-download-the-mbed-windows-serial-port


Académie de Rouen — Formations 2019Auteur : Fabrice Bossaert

Informatique

embarquée et

objets connectés

Jouer à Shifumi sur micro:bit Fiche élève

Présentation de la carte micro:bit

La carte micro:bit est un petit ordinateur, dont voici la description.

Capteur de température inté-gré au processeur

Boussole (compass)

Capteurs de mouvements(accéléromètre)

25 LEDs

Broches de connexion (pins)

Bouton de réinitialisation

Port USB

Connecteur batterie

Boutons A et B

La partie du micro:bit qui interprète et exécute les instructions est : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Le micro:bit peut être alimenté par un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .ou par . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Il existe pour le micro:bit plusieurs langages de programmation : par blocs (ici sera utilisé MakeCode, àl’adresse https://makecode.microbit.org), textuel (microPython avec Mu Editor). . .

L’interface de MakeCode res-semble beaucoup à celle deScratch.

Pour exécuter et tester un pro-gramme, il faut. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .dans le micro:bit.

Pour cela, on utilise le téléver-sement, qui se fait à l’aide d’uncâble USB, en appuyant sur :

Télécharger

Simulateur

Télécharger dansle micro:bit

Boîte à outils

Sauvegarde du programme

Espace de travail

33


https://codewith.mu

Partie A — Jouer à « pile ou face »

L’illustration ci-dessus présente les blocs nécessaires à l’élaboration d’un jeu de « pile ou face ». Il estpossible que chaque bloc soit utilisé plusieurs fois.

Règles

• Si l’utilisateur appuie sur le bouton A, c’est qu’il parie sur « Pile ». Un tirage aléatoire est effectué etla carte affiche « Gagné » ou « Perdu ».• Si l’utilisateur appuie sur le bouton B, c’est qu’il parie sur « Face ». La carte se comporte alors comme

ci-dessus.• Le tirage aléatoire donne soit 0, soit 1 ; l’un signifie « Pile », l’autre « Face ».

Codage

1. Aller sur https://makecode.microbit.org, démarrer un nouveau projet. Préparer tous les blocs commesur l’illustration.Lancer la simulation. Décrire ci-dessous ce qu’il se passe au démarrage du programme.

2. Assembler les blocs dans la partie toujours de manière à pouvoir jouer à « pile ou face » selon lesrègles énoncées ci-dessus.Lancer la simulation et faire vérifier par le professeur.Préciser ci-dessous le rôle de l’instruction toujours .

34


Partie B — Jouer à shifumi

Shifumi est le jeu de papier / pierre / ciseaux.Le geste traditionnel du joueur est de secouer la main avant de faire le signe papier, pierre ou ciseaux. Lemicro:bit sait détecter les mouvements.

Le capteur (accéléromètre, capteur gyroscopique) mesure l’accé-lération dans l’espace et peut donc générer des données de mou-vements. Il détecte aussi des actions telles que secouer, inclinerou tomber.X est le tangage (degré de balancement avant arrière), Y est leroulis (oscillation gauche droite) et Z la déviation (décalage hautbas).L’accéléromètre peut servir comme détecteur de mouvement. Ilest utilisé dans les montres connectées pour compter le nombrede pas que l’on fait.

Dans MakeCode, on peut remplacer la boucle toujours par la boucle lorsque secouer .

Règles

Deux joueurs ont chacun une carte micro:bit.Ils les secouent en même temps. Chaque carte affiche aléatoirement un symbole signifiant papier, pierreou ciseaux.Les règles classiques du jeu décident qui a gagné.

Codage

Les blocs nécessaires au codage du jeu sont présentés ci-dessus. Il est possible que chaque bloc soit utiliséplusieurs fois.Note : la variable tir peut être employée pour stocker le résultat du tir aléatoire.

Choisir trois icônes pouvant représenter le papier, la pierre et les ciseaux, puis coder le jeu.Tester à l’aide du simulateur puis appeler le professeur pour vérification.

35

Partie C — Deux cartes jouent à shifumi

Avec deux cartes micro:bit programmées comme ci-dessus, on peut déjà jouer au jeu de shifumi.Mais l’idéal serait que les cartes échangent entre elles et décident qui a gagné.

Onglet Radio

Radio définir groupe 1 Envoyer le nombre 0 par radio

Permet de créer un groupe pour communiquer (le

groupe 1).

Permet d’envoyer une donnée numérique.

Quand une donnée est reçue par radio receivedNumber

Permet de recevoir une donnée numérique et de la stocker dans la variable receivedNumber .

Principe de communication

1. Après avoir joué, le micro:bit numéro 1 envoie le résultat de son tirage aléatoire au micro:bit numéro 2.2. Le micro:bit numéro 2 reçoit l’information, et tranche sur la carte victorieuse.

Codage et réflexion

Coder le dialogue entre les deux micro:bit comme décrit ci-dessus.Des problèmes pratiques, liés au temps, se posent : les identifier et les écrire ci-dessous.

36


Académie de Rouen — Formations 2019Auteur : Fabrice Bossaert

Informatique

embarquée et

objets connectés

Jouer à Shifumi sur micro:bit Fiche professeur






Modalités

En demi-classe, par groupes de 2, avec ordinateur connecté à Internet.

Durée estimée selon les parties :• partie A — Jouer à « Pile ou face » : 10 minutes ;• partie B — Jouer à shifumi : 15 minutes ;• partie C — Deux cartes jouent à shifumi : 20 minutes, en aidant les élèves.

Descriptif

Au travers de la programmation de deux jeux, les notions suivantes sont découvertes :• allumer une (ou des) LED(s), se servir de la matrice de LEDs comme d’une IHM ;• gestion d’événements : appui sur bouton, capteur d’accéléromètre ;• communication sans fil.La programmation par blocs réinvestit largement ce qu’ont vu les élèves en collège sur Scratch.

Éléments de correction

Des éléments de correction sont disponibles en ligne∗.

37



Informatique

embarquée et

objets connectés

Simulation des clignotants et feux

stop d’un véhicule sur Sense Hat

Fiche élève

Objectif

De plus en plus de véhicules utilisent des LEDs pour leurs feux de signalisation (clignotants, feux deposition, feux stop. . .). Certains vont jusqu’à mutualiser, sur les mêmes LEDs physiques, au moins deuxfonctions, comme les feux de position avant et les clignotants.Le but de cette activité est d’utiliser un Raspberry Pi et un Sense Hat pour simuler au moins deuxdispositifs : clignotants et feux stop, avec leurs allumage et extinction pilotés par le joystick du Sense Hat.

Partie A — Création des images 8×8 et animations nécessaires

Quelques informations

• L’émulateur du Sense Hat en ligne est à l’adresse :

https://trinket.io/sense-hat

• Un code couleur est une liste de 3 entiers compris entre0 et 255, comme [255,128,0]. Le premier représentela composante rouge, le deuxième la composante verte,le troisième la composante bleue.Dans le code ci-contre, deux couleurs sont définies : lenoir et l’orange.

• Une image sur le Sense Hat est paramétrée, en Python,par une liste de 64 codes couleurs (un par LED de lamatrice du Sense Hat). Le programme ci-contre para-mètre les 64 LEDs pour afficher une flèche orientée versla gauche.

from sense_hat import SenseHathat = SenseHat()hat.clear()

n = [0,0,0]o = [255,127,0]

fleche_g = [n,n,n,n,n,o,o,n,n,n,n,o,o,o,n,n,n,o,o,o,o,n,n,n,o,o,o,o,n,n,n,n,n,o,o,o,o,n,n,n,n,n,n,o,o,o,n,n,n,n,n,n,n,o,o,n,n,n,n,n,n,n,n,n]

hat.set_pixels(fleche_g)

1. Créer et tester sur l’émulateur de Sense Hat deux autres images :• fleche_d représentant une flèche orange vers la droite ;• stop représentant un carré rouge (bordé ou non d’une autre couleur).

2. En Python, on charge la bibliothèque time par l’instruction :

from time import *

Dans cette bibliothèque, la fonction sleep permet de figer l’exécution d’un programme pendant unedurée passée en paramètre (en secondes) : sleep(0.5) stoppe le programme durant une demi-seconde.

Rédiger et tester une fonction clign :• prenant deux paramètres : une liste img représentant une image et un nombre t ;• affichant img sur le Sense Hat, l’éteignant au bout de t secondes, enfin attendant encore t secondes.

38


Partie B — Programmation événementielle du joystick

Le programme ci-dessous (fin de la page) est incomplet, et doit venir à la suite des images et fonctionsde la partie A.Des informations sur la programmation événementielle du Sense Hat sont données en annexe.

Objectifs du programme

• Lorsque le joystick est pressé vers la gauche, le Sense Hat affiche l’image de la flèche gauche et la faitclignoter. Cela s’arrête lorsque le joystick est relâché.• Même comportement, avec l’image de la flèche droite, lorsque le joystick est pressé vers la droite.• Lorsque le joystick est pressé vers le bas, l’image stop est affichée en continu. Cela s’arrête lorsque le

joystick est relâché.

Travail à faire

1. Au vu des informations en annexe, préciser ce que représentent les variables :liste_ev ev ev[1] ev[2]

2. Au vu des informations en annexe, préciser le rôle de la ligne 3 : if liste_ev != []

3. Compléter le programme, puis le tester sur le simulateur du Sense Hat.

Programme

1 while ...... :

2 liste_ev = hat.stick.get_events()

3 if liste_ev != []:

4 ev = liste_ev[-1]

5 if ev[1] == "left" and ev[2] != "released" :

6 clign(...... , ......)

7 elif .............. and .............. :

8 ..............

9 elif ev[1] == .............. and .............. :

10 ..............

11 else:

12 hat.clear()

39

Annexe

ÉvénementsLe joystick du Sense Hat produit des événements : par exemple, lorsqu’un utilisateuroriente le joystick vers la gauche (flèche gauche pour le simulateur).Un événement est traduit en Python par une liste à 3 éléments, par exemple :

[1566285329.511678, "left", "pressed"]Dans le détail :• l’élément de rang 0 représente l’heure de l’événement (en secondes depuis un

temps d’origine déterminé, en général le 1er janvier 1970) ;• l’élément de rang 1 précise la direction activée sur le joystick : "up", "down",

"left", "right", "middle" ;• l’élément de rang 2 précise l’action réalisée : "pressed" (pressé), "released"

(relâché), "held" (maintenu).

Joystick

Émulateur

Capture des événementsL’instruction hat.stick.get_events() enregistre dans une liste tous les événements qui se sontpassés depuis son dernier appel.

Cette liste peut être très longue : quand le joystick est maintenu pressé à gauche (événement [temps,".........." , ".........."]), la liste se remplit en continu.

Le dernier événement advenu s’obtient en prenant le dernier terme de la liste :liste_ev = hat.stick.get_events()ev = liste_ev[-1]

Tant que le joystick n’a pas été manipulé, l’instruction hat.stick.get_events() renvoie une listevide.

Boucle d’attente sans finDans un programme en Scratch, pour pouvoir capturer un événementcomme une action sur une touche, on place les instructions de capturedans une boucle sans fin (ci-contre).

C’est le même principe en Python, avec une boucle « Tant que » dontla condition est toujours vraie :

while True :...

40



Informatique

embarquée et

objets connectés

Simulation des clignotants et feux

stop d’un véhicule sur Sense Hat

Fiche professeur






Modalités

Cette séance prend appui sur la découverte du Sense Hat lors de l’activité « Manipulation d’une image8×8 sur Raspberry Pi et Sense Hat », du livret sur la photographie numérique.

Conditions envisagées : en demi-classe, une heure, avec l’émulateur en ligne :https://trinket.io/sense-hat

Le professeur dispose d’un Raspberry Pi et d’un Sense Hat pour montrer le résultat final en conditionsréelles.

Éléments de correction et commentaires

Partie A — Images possibles

fleche_g

Code couleur orange : [255,127,0]

stop

Code couleur rouge : [255,0,0]Code couleur gris : [127,127,127]

41



Partie B — Programme

1 while True:2 liste_ev = hat.stick.get_events()3 if liste_ev != []:4 ev = liste_ev[-1]5 if ev[1] == "left" and ev[2] != "released" :6 clign(fleche_g,0.2)7 elif ev[1] == "right" and ev[2] != "released" :8 clign(fleche_d,0.2)9 elif ev[1] == "down" and ev[2] != "released" :

10 hat.set_pixels(stop)11 else:12 hat.clear()

D’autres structures de programmation sont possibles, utilisant des fonctionnalités plus poussées de labibliothèque sense_hat ; voir la documentation du joystick sur :

https://pythonhosted.org/sense-hat/api/#joystick

Le choix fait ici a été de limiter au maximum le nombre de fonctions utilisées, et de se calquer sur lastructure de programme de boucle sans fin, comme vue par ailleurs sous Scratch en collège. Cela imposeen revanche d’examiner la structure des variables renvoyées par l’instruction hat.stick.get_events.

L’aspect « programmation objet » de ces instructions est intentionnellement laissé de côté pour ne pasperturber les élèves : l’instruction get_events est en effet une méthode de l’objet stick, lui-mêmeassocié à l’objet hat qui représente le Sense Hat.

Compléments sur Raspberry Pi et Sense Hat

Des compléments techniques sur le nano-ordinateur Raspberry Pi et le Sense Hat sont disponibles en ligne,concernant en particulier le coût de ce matériel, l’installation de l’émulateur du Sense Hat (possible surMac OS et GNU/Linux), et des liens vers de la documentation.

42

https://pythonhosted.org/sense-hat/api/#joystick




Informatique

embarquée et

objets connectés

Simulation d’une boussole sur Sense

Hat

Fiche élève

ObjectifLe Sense Hat dispose de trois capteurs présents également dans tout smartphone :• un gyroscope : il détecte l’orientation du support (Raspberry Pi + Sense Hat)

relativement à une position de départ ;• un accéléromètre : il détecte les modifications de la position du support ;• un compas : il détecte la direction du Nord magnétique.

L’objectif de cette activité est de visualiser l’orientation du Sense Hat par rapport auNord magnétique grâce à la matrice de LEDs ; on se contentera de travailler selon les8 secteurs principaux d’une rose des vents.

Partie A — Images pour le Sense Hat

Information

Un code couleur RVB pour une LED de la matrice 8×8 du SenseHat est une liste de 3 nombres entre 0 et 255 : le premier pour lacomposante rouge, le deuxième pour pour la composante verte et letroisième pour pour la composante bleue.

Plus d’informations dans l’activité « Manipulation d’une image 8×8 surRaspberry Pi et Sense Hat » du livret sur la photographie numérique.

Le code ci-contre définit trois images pour le Sense Hat, avec les codescouleurs suivants :

n = [0,0,0] r = [255,0,0]

1. Sur papier, sans aide de l’ordinateur, dessiner les images définies parles variables H, G et HG.Préciser ce qu’elles vont représenter dans le cadre de l’activité.

2. Rédiger le code Python pour 5 autres images, complétant ainsi larose des vents.

H = [n,n,n,r,r,n,n,n,n,n,r,r,r,r,n,n,n,r,r,r,r,r,r,n,r,r,r,r,r,r,r,r,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n]

G = [n,n,n,r,n,n,n,n,n,n,r,r,n,n,n,n,n,r,r,r,n,n,n,n,r,r,r,r,n,n,n,n,r,r,r,r,n,n,n,n,n,r,r,r,n,n,n,n,n,n,r,r,n,n,n,n,n,n,n,r,n,n,n,n]

HG = [r,r,r,r,r,n,n,n,r,r,r,r,n,n,n,n,r,r,r,n,n,n,n,n,r,r,n,n,n,n,n,n,r,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n,n]

43


Partie B — Une question d’orientation

La fonction hat.get_compass renvoie la direction du Sense Hat par rapport au Nord magnétique, endegrés (de 0 à 360), dans le sens horaire.Le Sense Hat doit être orienté l’encoche vers soi et tenu horizontalement (voir illustrations du tableauci-dessous).

1. Compléter le tableau ci-dessous et page suivante, avec, pour chacun des 8 cas :• l’angle en degrés renvoyé par hat.get_compass ;• le nom de l’image à afficher (voir partie A) ;• le dessin de l’image sur la grille du Sense Hat.

N

N

hat.get_compass() renvoie : 0Image à afficher : H

hat.get_compass() renvoie : 45Image à afficher : . . .

N

N

hat.get_compass() renvoie : . . .Image à afficher : . . .


44

N

N



N

N



2. La fonction secteur ci-contre prend pour argumentun nombre dir (la direction du Sense Hat par rap-port au Nord, en degrés), et renvoie l’image la plusappropriée pour cette direction.Ainsi :

•secteur(10)secteur(345)

´

doivent renvoyer H ;

•secteur(80)secteur(97)

´

doivent renvoyer . . .

Recopier et compléter la fonction, qui doit couvrir leshuit secteurs de la rose des vents.Faire vérifier par le professeur.

def secteur(dir):if dir > 22.5 and dir <= 67.5:

sect = HGelif dir > 67.5 and dir <= 112.5:

sect = ...elif ...

... # Autant de elif

... # que nécessaire

else:sect = H

return sect

45

Partie C — Mise en place de la boussole

1. Compléter le programme ci-contre, qui a pour but defaire fonctionner le Sense Hat comme une boussole.

while True:direction = hat.get_compass()fleche = secteur(...)hat.set_pixels(.......)

2. Compléter le fichier boussole_sense_hat.py∗ qui se trouve sur votre espace de travail, avec :• le code des images de la partie A ;• la fonction secteur de la partie B ;• la boucle sans fin de la question C-1.Tester le programme sur l’émulateur du Sense Hat.La rotation du Sense Hat est pilotée par le curseur « Yaw » (traduction : lacet) ; mais ce n’est pas leSense Hat qui tourne, c’est l’emplacement du Nord. . .

3. Renommer le fichier avec votre nom, puis l’envoyer au professeur pour un test sur le Sense Hat réel.

46



Informatique

embarquée et

objets connectés

Simulation d’une boussole sur Sense

Hat

Fiche professeur






Modalités

Cette séance prend appui sur la découverte du Sense Hat lors de l’activité « Manipulation d’une image8×8 sur Raspberry Pi et Sense Hat » du livret sur la photographie numérique.

Conditions envisagées : les parties A et B peuvent être réalisées en mode débranché, et donc en classeentière ; prévoir environ 1 h, à moins de faire démarrer l’activité à la maison.Le fichier boussole_sense_hat.py∗ à compléter étant distribué aux élèves, le codage de la partie Cnécessite moins d’une heure, en demi-classe, en travaillant sur l’émulateur en ligne :

https://trinket.io/sense-hatLe professeur dispose d’un Raspberry Pi et d’un Sense Hat pour montrer le résultat final en conditionsréelles.

Selon le degré de maîtrise de Python, il est possible que l’activité soit réalisée intégralement sur papier,avec des mises en commun régulières au vidéo-projecteur.

Variantes possibles

Voir la même activité sur micro:bit, avec programmation par blocs, Javascript ou Python, dans Programmerune boussole sur micro:bit.

Voir également, sur Appinventor, un programme plus élémentaire d’une boussole sur smartphone dansComment créer des applications Android utilisant les capteurs d’un smartphone ?

47



Commentaires techniques

La bibliothèque Python du Sense Hat, en particulier relativement au compas, est documentée sur la page :https://pythonhosted.org/sense-hat/api/#imu-sensor

Orientation du Sense Hat et des images

Le fichier boussole_sense_hat.py∗ présente l’instruction suivante :

hat.set_rotation(90)

Elle a pour but d’orienter les images de la matrice de LEDs pour un Sense Hattenu comme ci-contre (image de l’émulateur en ligne, orientée à la souris).

Explication

La manière d’orienter le Sense Hat est importante. Normalement, le Raspberry Pi est orienté avec la priseHDMI vers l’utilisateur, comme ci-dessous et comme pour l’émulateur Sense Hat lors de son lancement :

Mais le compas mesure l’angle entre le Nord magnétique et le Sense Hat orienté comme dans la partie B :

N

Angle renvoyé parhat.get_compass() :

135 degrés.

Les images envoyées vers la matrice de LEDs sont, elles, orientées « normalement » (prise HDMI verssoi) ; l’instruction hat.set_rotation(90) permet de corriger cela en leur faisant subir une rotation de90 degrés.

48

https://pythonhosted.org/sense-hat/api/#imu-sensor



Informatique

embarquée et

objets connectés

Pilotage d’un moteur à courant

continu

Fiche élève

Partie A — Pilotage local d’un moteur à courant continu

Afin de piloter un moteur à courant continu, on utilisera ici le ModuleShield ELECFREAKS connecté sur une carte micro:bit.

Ce Shield permet d’alimenter et de connecter plus facilement des capteurs et des actionneurs sur la cartemicro:bit. En particulier, il intègre un contrôleur de moteur TB6612 capable de piloter deux moteurs DC(1,2A 6-12V).

Quatre broches sont utilisées pour piloter le contrôleur TB6612 :• la broche digitale 8 contrôle le sens de rotation du moteur M1 ;• la broche digitale 12 contrôle le sens de rotation du moteur M2 ;• la broche digitale 1 contrôle la vitesse du moteur M1 avec un signal PWM (voir définition page

suivante) ;• la broche digitale 2 contrôle la vitesse du moteur M2 avec un signal PWM.

49

Un signal PWM (Pulse Width Modulation en anglais) ou MLI(Modulation de Largeur d’Impulsion en français) est un signalnumérique, dont la tension peut prendre deux valeurs seulement :0 et 1.

Le principe général est qu’en appliquant une succession de 0 et de1 pendant des durées bien choisies, on peut obtenir en moyennesur une certaine durée n’importe quelle valeur intermédiaire detension et ainsi moduler une distribution de puissance (variationdu rapport cyclique = duty cycle).

En langage Python, le réglage du « rapport cyclique » d’un signalPWM est déterminée par une variable entière comprise entre 0et 1023.

Pulse Width Modulation

Rapport cyclique 0%

Rapport cyclique 25%




1. Compléter le tableau ci-dessous, de façon à déterminer les deux comportements du moteur 1.

Comportement du moteur 1 Niveau logique de la broche 8Valeur de la variable de

réglage PWM de la broche 1

Tourne dans sens 1 à 25% de sa vitesse

Tourne dans sens 2 à 50% de sa vitesse

2. Voici une liste de composants. Réaliser le montage de la photo du bas de la page.

Pile 9V et coupleur

Moteur DC

Module ShieldELECFREAKS connecté surmicro:bit

Coupleur câblé entre Vin

(rouge) et GND (noir)Moteur DC câblé entre M1−et M1+

50

3. Réaliser un programme Python permet-tant indéfiniment de faire tourner pen-dant 1 seconde le moteur 1 dans un sensà 25% de sa vitesse maximale, puis defaire tourner ce même moteur en sensinverse à 75% de sa vitesse maximaleégalement pendant 1 seconde.

Saisir le programme, puis le « flasher »sur la carte micro:bit. Après avoir posi-tionné l’interrupteur du Shield sur ON,vérifier le comportement du moteur afinde valider le programme.

Instructions Python utiles

L’instruction pinX.write_digital(value)

permet d’écrire un niveau logique sur une broche de sortie :• X désigne le numéro de la broche ;• value spécifie le niveau logique (1 ou 0).

L’instruction pinX.write_analog(value)

permet de générer un signal PWM sur une broche de sortie :• X désigne le numéro de la broche ;• value spécifie la valeur du rapport cyclique (0 pour 0%,

1023 pour 100%).

4. De façon à répondre au même cahier des charges (1 seconde le moteur 1 dans un sens à 25% de savitesse max, puis 1 seconde en sens inverse à 75% de sa vitesse max), simplifier l’écriture du programmeprécédent en créant une fonction :

commande_mot1 (sens, vitesse)possédant deux paramètres :• sens : un booléen indiquant le sens de rotation du moteur 1 ;• vitesse : un entier définissant la vitesse du moteur 1 à travers la valeur du rapport cyclique.

5. En réutilisant la fonction commande_mot1 définie à la question 4, faire évoluer le programme précédentde façon à satisfaire au tableau de fonctionnement ci-dessous :

Boutons poussoirs Moteur 1

Aucun appui Arrêt

Appui sur BP A Sens 1 à 50% de sa vitesse max

Appui sur BP B Sens 2 à 50% de sa vitesse max

Partie B — Pilotage à distance d’un moteur à courant continu

Principe du pilotage d’un objet à distance

⇐⇒

Smartphone Androidassocié à sonprogrammeAppinventor

ModuleBluetooth

micro:bit associé à sonprogramme Python

Liaison sans filBluetooth

Liaison filairesérie RS232

51

« L’objet » piloté ici sera le moteur DC connecté au ShieldELECFREAKS.

Le module Bluetooth permet d’établir une liaison entre lesmartphone et la carte micro:bit :• vis-à-vis du smartphone, il s’agit d’une liaison sans fil

Bluetooth ;• vis-à-vis de la carte micro:bit, il s’agit d’une liaison filaire

série RS232.

Remarque : bien que disposant d’un module Bluetooth in-tégré, la carte micro:bit ne dispose pas suffisamment demémoire RAM pour le faire fonctionner correctement enmicroPython.

Pour piloter un objet à distance, il est toujours né-cessaire d’élaborer deux programmes :• un programme qui gère l’IHM (Interface Homme-

Machine) et la liaison sans fil Bluetooth ;• un programme qui gère la liaison filaire série RS232

et l’objet piloté.

Compléter les éléments ci-dessous.• Hébergement de la gestion de l’IHM :

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .• Hébergement de l’IHM :

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .• Hébergement de la gestion du pilotage :

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .• Hébergement de la gestion de la RS232 :

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Description de la liaison filaire série RS232

La liaison RS-232 est issue de la norme dumême nom qui permet l’envoi de données via unechaîne de niveaux logiques envoyés en série (d’oùle nom du « port série » d’un ordinateur). Ellepermet de faire dialoguer deux systèmes entreeux. Les données sont envoyées par trames de 8bits, soit autant de niveaux logiques.Elle est appelée asynchrone car aucune horlogen’est transportée avec le signal de données. Ellenécessite un minimum de 3 fils comportant lestrames de données en émission (Tx) et en récep-tion (Rx).

Remarque

Avec une connexion Internet, l’IHM pourrait être hébergée sur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

52

Prise en main de AppInventor

Une vidéo de prise en main du logiciel AppInventor est disponible en ligne∗. AppInventor n’est compatiblequ’avec les smartphones fonctionnant sous Android.Ce logiciel est disponible en ligne, sans authentification, à l’adresse :


Programmation de l’IHM : application Android sur AppInventor

L’objectif est maintenant de créer une application Android disposant de deux boutons « Marche » et« Arrêt » et permettant de faire fonctionner le moteur dans un sens à 50% de sa vitesse ou de l’arrêter.

1. Se connecter à l’adresse ci-dessous, choisir l’option « Sans compte » et noter le code du projet.


2. La programmation de l’IHM se réalise en deux étapes :a) dans le « Designer », préparer tous les composants comme indiqué dans le document 1 ci-après ;b) dans les « Blocs », réaliser les programmes du document 2.

Une fois le programme fini, télécharger le fichier .apk puis le téléverser en utilisant le câble USB devotre smartphone, ou en « flashant » le QR-code généré par Appinventor.

Document 1 — Apparence de l’IHM

Écran du terminal Composants installés

53



Document 2 — Programmation de l’IHMRécupération de la liste despériphériques Bluetooth ap-pairés sur le smartphone.Si la connexion au périphé-rique sélectionné est réali-sée. . .

Alors :• afficher l’état de la

connexion ;• faire disparaître la liste des

périphériques ;• faire apparaître le bouton

de déconnexion.

Lorsque l’événement « Marchecliqué » apparaît, envoyer lecaractère « M » sur le portBluetooth.

Lorsque l’événement « Arrêtcliqué » apparaît, envoyer lecaractère « A » sur le portBluetooth.

Lorsque l’événement « Bou-ton déconnexion cliqué » ap-paraît :• déconnecter la liaison

Bluetooth ;• afficher l’état de la

connexion ;• faire apparaître la liste des

périphériques ;• faire disparaître le bouton

de déconnexion.

54

Programmation en Python de l’objet piloté

1. Le montage de la partie Acomportait :• un module Shield ELEC-

FREAKS (connecté surune carte micro:bit) ;• un moteur DC ;• une pile 9V et son cou-

pleur associé.Compléter ce montageavec un module Bluetoothcomme ci-contre.

Connexions du moduleBluetooth :• GND sur GND• VCC sur +3.3V• TX sur pin3

2. Compléter et saisir le programme ci-dessous de façon à faire fonctionner le moteur dans un sens à 50%de sa vitesse ou de l’arrêter suivant la réception du caractère « M » ou « A ».Réutiliser la fonction commande_mot1 de la partie A pour piloter le moteur 1.

from microbit import *

def commande_mot1(sens, vitesse): # Définition de la fonction commande_mot1......

uart.init(baudrate=9600, bits=8, parity=None, stop=1, rx=pin3)# Initialisation de la liaison série : réception (rx) sur broche 3# Protocole Bluetooth : 9600 bits/s, 8 bits de données,# 1 bit de stop, pas de bit de parité

......................... # À compléter : moteur à l’arrêt au démarrage

while True :if uart.any() : # Si une donnée est disponible

donnee_lue_microbit = uart.read() # Lire la donnée et la mémorisermsg = str(donnee_lue_microbit, "UTF-8")if msg == "M" : # Si la donnée est égale à "M"

................... # M1 tourne à 50% de sa vitesseelif msg == "A" : # Si la donnée est égale à "A"

................... # M1 est à l’arrêt

3. « Flasher » le programme sur la carte micro:bit.Sur le smartphone, appairer le module Bluetooth (code par défaut 1234).À partir de l’application Android, se connecter au module Bluetooth.Après avoir positionné l’interrupteur du Shield sur ON, vérifier le comportement du moteur afin devalider le programme.

55



Informatique

embarquée et

objets connectés

Pilotage d’un moteur à courant

continu

Fiche professeur






L’objectif de cette activité est de commander un moteur à courant continu localement et à distance.

Modalités

En prérequis, l’enseignant de mathématiques doit avoir abordé Python et les élèves connaissent déjà l’IDEMu et la carte micro:bit (voir le TP sur le podomètre par exemple). Idéalement, les élèves ont déjà réaliséun TP sous Appinventor ; un tutoriel vidéo est en ligne∗.

Environ 2h, travail individuel en demi-classe devant ordinateur, possibilité de travailler en binôme.

Il est possible de scinder cette activité en deux parties de façon à faire un travail préparatoire en classeentière avant de passer aux activités pratiques en demi-classe.

Pour gagner un peu de temps et éviter les erreurs de câblage des élèves, les montages peuvent être câblésen amont par le professeur.

Concernant l’évaluation, il est possible de ramasser et noter le compte-rendu. Cependant, il peut être plusefficace de noter à « la volée » durant l’activité, en fixant au préalable des points d’étapes aux élèves afinde faire le bilan ensemble.

Descriptif

Partie A — Pilotage local d’un moteur à courant continu

Les élèves découvrent comment envoyer des 1 et des 0 sur les ports d’un micro-contrôleur, ainsi que leprincipe d’une modulation de largeur d’impulsion. Ils finissent par mettre en œuvre une fonction permettantd’optimiser la commande du moteur.

Partie B — Pilotage à distance d’un moteur à courant continu

Travail sur Appinventor, logiciel permettant de programmer graphiquement des applications sous Android.Comme il n’est pas possible à l’heure actuelle d’utiliser les fonctionnalités natives du Bluetooth sur la cartemicro:bit, les élèves mettent en œuvre un module Bluetooth dédié afin de piloter à distance le moteur àcourant continu.Là aussi, il est possible de gagner du temps en donnant l’application Appinventor (fichier .apk)aux élèves.

56


Académie de Rouen — Formations 2019Auteur : Benoît Dherbecourt

Informatique

embarquée et

objets connectés

Comment piloter un robot à

distance ?

Fiche élève

Situation

L’objectif est de commander à distance le déplacement du robot Bit:Bot. On dispose pour cela de deuxcartes micro:bit : l’une émettrice et l’autre réceptrice. La première servira de télécommande, la secondepermettra de réceptionner les données afin de contrôler les deux moteurs électriques du robot pour qu’ilpuisse se déplacer (voir vidéo∗).

Partie 1 — Programmer la carte émettrice (radiocommande)

La carte émettrice fonctionnera de la manière suivante :

• si les boutons A et B sont pressés alors le robot avance et la flèche ci-contreest visible sur la carte ;

• si uniquement le bouton A est pressé alors le robot tourne à gauche et laflèche ci-contre est visible sur la carte ;

• si uniquement le bouton B est pressé alors le robot tourne à droite et laflèche ci-contre est visible sur la carte ;

• si les boutons ne sont pas pressés alors les LEDs ci-contre sont allumées.

57

1. Ouvrir le logiciel MakeCode en suivant le lien : https://makecode.microbit.org

2. Cliquer sur « nouveau projet ».

3. À l’aide des blocs « Base », « Entrées » et « Logique », réaliser un programme permettant de simulerl’allumage des LEDs en fonction des touches A et B.

Commande de simulation

4. On se concentre désormais sur la partie du pilotage à distance.Ouvrir le logiciel MU Editor (https://codewith.mu).

5. Charger le fichier :emetteur.py∗

Son contenu est reproduit ci-contre.On observe sur le programme im-porté le module radio. La radiopermet de communiquer sans filentre plusieurs micro:bits. On peutdonc utiliser la radio pour envoyerdes messages aux autres micro:bits.

En observant le contenu du fichier,indiquer le message envoyé quand :

• A et B sont pressés : . . . . . . . .

• seul A est pressé : . . . . . . . .

• seul B est pressé : . . . . . . . .

• A et B sont relâchés : . . . . . . . .


import radio

radio.on()

radio.config(channel=1)

radio.config(power=7)

while True:

txMsg = ""

if button_a.is_pressed() and button_b.is_pressed():

txMsg = "A"

display.show(Image.ARROW_N)

elif button_a.is_pressed():

txMsg = "G"

display.show(Image.ARROW_W)

elif button_b.is_pressed():

txMsg = "D"

display.show(Image.ARROW_E)

else:

txMsg = ""

display.show(Image.YES)

radio.send(txMsg)

sleep(10)

6. En se reportant à la simulation réalisée en début de séance, indiquer la signification de la commandedisplay.show(Image.ARROW_N).

58


https://codewith.mu

Partie 2 — Programmer la carte réceptrice (carte robot)

La carte réceptrice est fixée au robot. Le programme recepteur.py∗, donné en annexe page suivante,permet de recevoir les données de la radiocommande et de contrôler les deux moteurs électriques du robot.L’objectif de cette partie est de le compléter en trouvant ce qui se cache derrière les points d’interrogation.

1. Les cartes micro:bit peuvent communiquer sur différents canaux (numérotés de 0 à 83 : on parle desyntonisation). Cela fonctionne exactement de la même manière que les radios talkies-walkies : toutle monde syntonise le même canal et tout le monde entend ce que tout le monde diffuse via ce canal.

En observant le programme de l’émetteur, compléter laligne de commande ci-contre.

radio.config(channel=...)

2. Les moteurs sont connectés au micro:bit sur les broches suivantes :• moteur de gauche (left) : broche PWM 0 (vitesse), broche 8 (direction)• moteur de droite (right) : broche PWM 1 (vitesse), broche 12 (direction)

ExempleCode Python de la

broche 3 :pin3

Lorsqu’on veut piloter le sens de rotation des moteurs (changement de direction), on commence parutiliser write_digital(0) pour que les moteurs fassent avancer le robot ou write_digital(1) pourle faire reculer.

On utilise ensuite write_analog avec un paramètre entre 0 et 1023 sur les broches PWM pour définirla vitesse du moteur (voir plus loin question 4).

À l’aide des informations ci-dessus, compléter les lignes decommande ci-contre.

leftSpeed = pin...leftDirection = pin...rightSpeed = pin...rightDirection = pin...

3. À l’aide du programme emetteur.py∗, compléter les lignesde commande ci-contre.

elif incoming == "...":gentleLeft()display.show(Image.ARROW_W)

elif incoming == "...":gentleRight()display.show(Image.ARROW_E)

else:stop()display.show(Image.TARGET)

4. L’instruction write_analog prend en paramètre un entier entre 0 et 1023 ; ainsi :• write_analog(0) donne une vitesse de rotation nulle ;• write_analog(1023) donne la vitesse de rotation maximale.

Sachant que l’on souhaite faire avancer le robot à peu prèsà 50% de sa vitesse maximale, compléter la ligne de com-mande ci-contre.

if incoming == "A":drive(...)display.show(Image.ARROW_N)

5. Toujours à l’aide du logiciel MU Editor, charger le programme recepteur.py∗ et vérifier les réponsesaux questions précédentes.

6. Modifier les deux programmes afin de changer l’allumage des LEDs ainsi que la vitesse des moteurs.

Aide sur les LEDs : https://microbit-micropython.readthedocs.io/en/latest/tutorials/images.html

Source d’inspiration de cette activité : http://multiwingspan.co.uk/micro.php

59

https://microbit-micropython.readthedocs.io/en/latest/tutorials/images.html

http://multiwingspan.co.uk/micro.php

Annexe — Programme recepteur.py∗


import radio

radio.on()

radio.config(channel=?)

radio.config(power=7)

leftSpeed = pin?leftDirection = pin?rightSpeed = pin?rightDirection = pin?

def move(gaucheV, droiteV, gaucheD, droiteD):

leftSpeed.write_analog(gaucheV)

rightSpeed.write_analog(droiteV)

leftDirection.write_digital(gaucheD)

rightDirection.write_digital(droiteD)

def drive(speed):

move(speed, speed, 0, 0)

def gentleRight():

move(200, 0, 0, 0)

def gentleLeft():

move(0, 200, 0, 0)

def stop():

move(0, 0, 0, 0)

while True:

incoming = radio.receive()

if incoming is not None:

if incoming == "A":

drive(?)

display.show(Image.ARROW_N)

elif incoming == "?":

gentleLeft()

display.show(Image.ARROW_W)

elif incoming == "?":

gentleRight()

display.show(Image.ARROW_E)

else:

stop()

display.show(Image.TARGET)

60


Académie de Rouen — Formations 2019Auteur : Benoît Dherbecourt

Informatique

embarquée et

objets connectés

Comment piloter un robot à

distance ?

Fiche professeur





Modalités

L’activité doit permettre la prise en main rapide d’un micro-contrôleur afin que les élèves puissent écrireun programme simple d’acquisition de données et de commande d’actionneurs, et le tester.

Le début de l’activité se fait de manière intuitive puisque les élèves partent d’un environnement informatiquequ’ils connaissent : programmation par briques de couleurs différentes. Il n’y a donc pas besoin de tutorielpour cette première partie ; il s’agit même d’un rappel en lien avec les activités Scratch réalisées au collègeen mathématiques et en technologie.

La suite se fait par analogie, les élèves comparent leur programme, réalisé lors de la simulation, avec leprogramme Python qui leur est proposé en répondant à quelques questions.

La seconde partie est une analyse du programme recepteur.py∗ permettant la réception des donnéeset le contrôle des deux moteurs. Une courte vidéo∗ peut être montrée avant l’activité afin que les élèvesexaminent le mode de fonctionnement du système de commande.

Pourquoi le choix de carte micro:bit ?

• Les cartes micro:bit peuvent communiquer entre elles paronde « radio ». On peut donc imaginer un seul robot pourune classe commandé à distance par les élèves via leur micro-contrôleur (une carte micro:bit par groupes de cinq ou sixélèves). Le robot ne pouvant pas être commandé par plusieurscartes simultanément, il reviendra au professeur de changerle canal de fréquence sur la carte réceptrice du robot afin depermettre à chaque groupe d’élèves de tester son programme.• La programmation Python permettant la communication sans fil entre les cartes se fait très simplement.

• Un logiciel de simulation de la carte micro:bit est accessible en ligne : Mu Editor (https://codewith.mu).

Pour aller plus loin

Une fois les deux programmes assimilés, les élèves pourront à loisir les modifier afin d’augmenter oudiminuer la vitesse de progression du robot, le faire reculer et jouer sur l’affichage des LEDs de la cartemicro:bit.

61

https://codewith.mu


Académie de Rouen — Formations 2019Auteur : Samuel Lebouis

Informatique

embarquée et

objets connectés

Comment les objets connectés

peuvent venir en aide aux personnes

à mobilité réduite ?

Fiche professeur






Modalités

Cette série d’activités utilise d’une part la carte micro:bit sans ajout de capteur ou actionneur, d’autrepart AppInventor. Le but est de simplifier au maximum la mise en pratique des élèves.

Descriptif

L’entrée de cette activité est l’utilisation des objets connectés comme une aide pour les personnes âgées.Un mini-débat sur la recherche de solutions peut démarrer la séance.

Le tableau suivant est alors projeté et les élèves (par groupes de 2) doivent se positionner sur la résolutiond’un problème. La contrainte est l’utilisation d’une micro:bit ou d’une application Android créée avecAppInventor. Les ressources quant aux deux outils utilisés sont à disposition des élèves.

Questions Outils préconisésComment appeler rapidement les membres de sa famille sans avoir àaller dans le répertoire du téléphone ? AppInventor

Comment envoyer un SMS directement à un membre de la famille encas de suspicion de chute ? AppInventor

Comment afficher la température et prévenir d’aller s’hydrater en casde fortes chaleurs ? micro:bit

Après avoir choisi une question, chaque groupe devra imaginer sa solution et noter les capteurs et action-neurs utilisés. Une présentation de sa solution pour chaque groupe viendra conclure cette activité. Lesdifférentes structurations des connaissances seront écrites après les présentations.

Durée : 15 minutes d’introduction, 30 minutes de recherche papier en groupes, 1h30 de programmation.

62

Exemples de solutions

Les solutions montrées succinctement ici ne sont que des exemples. En classe, les élèves auront tous leschoix possibles pour développer leurs propres programmes.

Comment appeler rapidement les membres de sa famille sans avoir à aller dansle répertoire du téléphone ?

L’accent est mis sur la simplicité de l’IHM, la résolution des photos sera aussi abordée (rappel du chapitresur la photographie numérique). Prendre soin d’utiliser des photographies libres de droits si les élèves n’ontpas de photographies personnelles.

Il faut insérer la photo de chaque personne dans uncomposant BOUTON.Chaque personne aura aussi un composant « appeltéléphonique » avec son numéro de téléphone à pa-ramétrer dans la colonne Propriétés.

Programmation dans l’onglet Blocs

63


Comment envoyer un SMS directement à un membre de la famille en cas desuspicion de chute ?

Comment afficher la température et prévenir d’aller s’hydrater en cas de fortechaleur ?

Un exemple de programme, cette fois sous Blocklino, qui traduit les blocs en Python.

64

Synthèse du contenu des activités

Act

.co

nnec

tée

Act

.dé

bran

chée

App

Inve

ntor

Car

teA

rdui

no

Car

tem

icro

:bit

Pi+

Sens

eH

at

Pro

g.pa

rbl

ocs

Pro

g.P

ytho

n

Comment créer des applications Android utilisant lescapteurs d’un smartphone ?

x x x

Algorithmes de contrôle de comportements physiques x

Ventilateur contrôlé par la température sur Arduino x x x

Programmer une boussole sur micro:bit x x x x x

Un podomètre sur micro:bit x x x

Jouer à Shifumi sur micro:bit x x x

Simulation des clignotants et feux stop d’un véhicule surSense Hat

x x x

Simulation d’une boussole sur Sense Hat x x x x

Pilotage d’un moteur à courant continu x x x x x

Comment piloter un robot à distance ? x x x x

Comment les objets connectés peuvent venir en aide auxpersonnes à mobilité réduite ?

x x x x

Artisans de ce livret ou de la formation associée

65

Livret « Informatique embarquée et objets connectés » Deuxième...

Documents

Transcript of Livret « Informatique embarquée et objets connectés » Deuxième...