Les objets connectés pour enseigner

l’algorithmique
en lycée professionnel
Groupe InEFLP

de l’IREM*de Marseille

13 mai 2023

* Institut de Recherche sur l’Enseignement des Mathématiques

 Table des matières
À propos de cette publication 5
Pourquoi les objets connectés ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Qui sommes-nous ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Liens utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

À propos de la carte Micro:bit 7

Bref historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
La carte Micro:bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Programmer la carte Micro:bit par blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Programmer la carte Micro:bit en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Mémo : les blocs principaux Micro:bit 12

Ton premier programme avec Micro:bit 15

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

Commande de base pour Micro:bit (et python) 18

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Commandes essentielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Des commandes pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Superviser le travail des élèves sur Micro:bit 32

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Mode d’emploi de Classroom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Borne de satisfaction avec Micro:bit 37

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Niveau initiation - Premier modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Niveau expert - Cumuler les votes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Les fractions avec Micro:bit 42

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Écrire une fraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Afficher une fraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Somme de fractions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

Dé à 6 faces avec Micro:bit 46

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Niveau simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

2
 Niveau intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

Normal ou truqué ? avec Micro:bit 50

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Pile ou face avec Micro:bit 53

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Niveau simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Niveau intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Niveau expert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

Fluctuation d’échantillonnage avec Micro:bit 60

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Niveau prise en main - Vérifier le modèle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Niveau intermédiaire - Générer des échantillons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Niveau avancée - Produire des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Chutes et oscillations avec Micro:bit 68

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Niveau simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Niveau intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Mémo Mu-Editor pour Micro:bit (et python) 73

Mémo Micro:bit (et python) 75

Simuler un dé avec Micro:bit (et python) 78

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Niveau initiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Niveau intermédiaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Niveau avancé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

Pile ou face communicant avec Micro:bit (et python) 86

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Niveau simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Niveau Expert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

Robot Maqueen et capteur de distance 91

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Niveau initiation - Utilisation du capteur de distance à ultrasons . . . . . . . . . . . . . . . . . . . 94

3
 Niveau intermédiaire - Étalonnage du capteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Niveau expert - Robot autonome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

Déterminer une vitesse avec MBot 98

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Niveau initiation - Programmer le déplacement de MBot . . . . . . . . . . . . . . . . . . . . . . . 99
Niveau intermédiaire - Déterminer la vitesse de MBot . . . . . . . . . . . . . . . . . . . . . . . . . 100

Vitesse de rotation avec MBot 101

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Niveau initiation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

Variation de vitesses avec MBot 103

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
Niveau initiation - Nature du mouvement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Niveau expert - Mouvement décéléré . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

Normal ou truqué ? avec STM32 Éducation 106

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

Pile ou face avec STM32 Éducation 109

Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Progression proposée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Niveau initiation - Premier modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Niveau intermédiaire - Pile ou Face . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Notes pour l’enseignant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Niveau intermédiaire - 16 tirages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Niveau expert - Initialisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Niveau expert - 32 tirages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Niveau expert - Enregistrer les effectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

4
 À propos de cette publication

P OURQUOI LES OBJETS CONNECTÉS ?

Alors que dans certaines disciplines le temps commence à manquer pour traiter l’ensemble du pro-
gramme, certains évoquent déjà l’idée d’en faire plus !
En effet, les enseignants utilisent déjà les outils numériques. Par exemple, dans les classes de ma-
thématiques, l’utilité du tableur et de GeoGebra n’est plus à démontrer. Jusqu’à l’introduction de
l’algorithmique, ces deux logiciels efficaces et maîtrisés par les enseignants étaient amplement suf-
fisants. Est-ce donc juste un effet de mode de faire cours avec les robots (Thymio, Mbot), les objets
programmables et connectés (Arduino, Micro:bit, STM education, Raspberry Pi) ou est-ce une nou-
velle façon d’aborder notre enseignement ? Ces nouvelles possibilités technologiques, forcément
chronophages, nous permettront-elles de traiter un contenu disciplinaire exigeant dans un cadre
institutionnel contraignant ?
Nous n’avons bien sûr pas toutes les réponses à ces questions mais nous pensons que lorsqu’il est
accompagné de certains de ces outils, notre enseignement a beaucoup à y gagner.
L’introduction de l’algorithmique en lycée professionnel nous interroge. Longtemps il nous a semblé
impensable et inenvisageable d’avoir à enseigner un langage de programmation comme Python
auprès d’un public d’élèves globalement en difficulté avec les mathématiques. Fort de ce constat,
nous avons cherché les moyens de lier les mathématiques à la logique et au raisonnement algorith-
mique. C’est pourquoi nous avons exploré les potentialités des objets connectés.

Notre postulat est double. Nous pensons que :

— grâce à des situations réelles et concrètes, les objets connectés facilitent la mise en
activité de tous les élèves ;
— grâce à des activités simples mais évolutives centrées autour de réalisations maté-
rielles, la dimension affective du travail est valorisée. Soyons fous et espérons que
l’élève tisse une histoire personnelle avec l’activité, qu’il soit fier du travail accompli
et qu’il prenne également du plaisir à expliquer et à montrer ses réalisations.

En devenant de plus en plus simples, accessibles et facilement utilisables, les objets connectés per-
mettent d’aborder des contenus disciplinaires et de développer des compétences transversales
essentielles pour l’élève.
En travaillant à partir des objets connectés, la situation de départ est plus concrète et l’objectif à
atteindre suffisamment clair pour l’élève. Plus ou moins guidé selon son niveau d’expertise tech-
nique, il est alors libre dans sa démarche. Avec des interfaces de programmation accompagnées
parfois de simulateurs, la démarche par essais et erreurs a ici toute sa place. Par ailleurs, l’élève de-
vra clarifier sa pensée avant de verbaliser ses idées en langage naturel. Il pourra ainsi proposer et
élaborer un modèle acceptable par la machine pour enfin traduire son algorithme en se pliant à la
rigueur du langage de programmation.
Effectuant régulièrement des va-et-vient entre abstraction et réalité, cherchant à valider son algo-
rithme à partir d’un visuel ou d’une exploitation des résultats, l’élève entre progressivement dans la
modélisation.
Les scénarios proposés dans cette brochure permettent tout cela : une approche des mathéma-
tiques et des sciences qui laisse la place à l’expérimentation : manipulation, programmation et
auto-validation.

5
Q UI SOMMES - NOUS ?
Nous sommes des enseignants de maths/sciences regroupés au sein d’un groupe de recherche de
l’IREM de Marseille.

Notre groupe, Innovation, Expérimentation et Formation en Lycée Professionnel (InEFLP) consacre

une partie de son travail à l’enseignement de l’algorithmique en classes de lycée professionnel.
Dans le cadre de cette recherche, nous explorons les objets connectés tels que Arduino, Micro:bit,
STM32 Éducation ou mbot.

L IENS UTILES
Page du groupe InEFLP
[Link]
IREM de Marseille Site académique de l’IREM de Marseille
[Link]
Portail des IREM Site national des IREM
[Link]
Formation à l’algorithmique LP et SEGPA Padlet de utilisé lors de nos formations académiques
[Link]
Collecte de ressources pour Micro:bit Padlet sur Micro:bit utilisé en formation
[Link]
Brochure sur Micro:bit Publication de la C2i TICE pour une prise en main de Micro:bit
[Link]
Description Micro:bit Fiche sommaire de description de Micro:bit
[Link]
Site IREM dédié à Micro:bit Site de ressources sur Micro:bit du groupe
[Link]

6
 À propos de la carte Micro:bit
Micro:bit est un microcontrôleur développé au Royaume-Unis. Par ses caractéristiques techniques
et ses interfaces pédagogiques, cet objet possède un fort potentiel pour l’enseignement de l’algo-
rithmique.
Après un bref rappel historique, nous expliquerons plus en détail les carac-
téristiques propres de cet objet. Nous mettrons ensuite en avant la facilité
de mise en œuvre en formation puis nous poursuivrons en donnant un pre-
mier aperçu de l’intérêt pédagogique de Micro:bit.

Carte Micro:bit
B REF HISTORIQUE
Le développement de Micro:bit s’inscrit dans le cadre d’une politique
volontariste de développement de l’apprentissage de la programma-
tion. L’objectif premier visait à équiper tous les élèves de 11/12 ans du
Royaume-Unis ainsi que leur enseignant. Maintenant que c’est chose
faite, le reste du monde peut en profiter aussi.
La BBC 1 est le moteur de ce projet. 30 ans après sa première distribution d’ordinateurs aux enfants
britanniques 2 , “la Vieille Dame” remet ça aujourd’hui. La BBC utilise ses moyens de diffusions pour
promouvoir et accompagner les utilisateurs, notamment en proposant des émissions de TV dédié à
cet objet sur un mode ludique et divertissant. Sur les 29 3 partenaires de ce projet, se trouvent entre
autres Microsoft 4 pour une partie logiciel et interface de programmation, ARM 5 pour la construc-
tion des processeur et la partie matériel, et Samsung 6 pour un support mobile. C’est donc un projet
qui mobilise des acteurs majeurs du numériques et de la communication, prévu pour durer.

LA CAR TE Micro:bit
Concrètement de quoi s’agit-il ? On parle ici de microcontrôleur, à savoir une carte électronique
programmable pour interagir avec le monde réel. C’est une version accessible de l’électronique
que tout un chacun manipule au quotidien sans se poser de question, par exemple les dispositifs de
domotique qui permettent de gérer à distance le chauffage, la sécurité, l’arrosage du géranium. . .
Ou bien plus simplement la bouilloire programmable au degré ◦ C près, la guirlande du sapin qui
clignote au rythme de Jingle Bells. Ce microcontrôleur permet d’élaborer par exemple un podo-
mètre, un doudou sensoriel, un sismographe rudimentaire. . .
L’interface de programmation est conçue pour être utilisable par un enfant d’une dizaine d’année,
c’est donc la simplicité qui prime. On dispose en première approche d’une application internet uti-
lisant le principe de la programmation par bloc, à savoir sur le principe des Blockly que l’on retrouve
dans Scratch ou StudioCode. En plus d’une programmation accessible, l’interface propose une si-
mulation de la carte. Ceci permet de voir directement les effets du programme dans l’interface.
Pour un usage plus avancé il est notamment possible de programmer avec le langage Python 7 ou
Javascript.
1. Make It Digital - The BBC micro :bit. (s. d.). Consulté 29 mars 2017, à l’adresse [Link]
articles/4hVG2Br1W1LKCmw8nSm9WnQ/the-bbc-micro-bit
2. BBC Micro. (2016, septembre 20). In Wikipédia. Consulté à l’adresse [Link]
Micro&oldid=129763631
3. Partners. (s. d.). Consulté 29 mars 2017, à l’adresse [Link]
4. The BBC micro :bit and Microsoft - Microsoft Research. (s. d.). Consulté 29 mars 2017, à l’adresse [Link]
[Link]/en-us/research/project/the-bbc-microbit-and-microsoft/
5. Ltd, A. R. M. (s. d.). ARM | Innovation Hub - BBC micro :bit. Consulté 29 mars 2017, à l’adresse [Link]
innovation/products/[Link]
6. Code on the go with Samsung & micro :bit. (s. d.). Consulté 29 mars 2017, à l’adresse [Link]
citizenship/[Link]
7. Python editor. (s. d.). Consulté 29 mars 2017, à l’adresse [Link]

7
 Détails des entrées/sorties d’une carte Micro:bit

Bien entendu de nombreux exemples de

projets existent, qu’ils soient issus des émis-
sions BBC ou de la communauté éducative.
Sur le site officiel on trouve des idées, des tu-
toriels, des leçons a comme par exemple :
une alarme de trousse, un compteur de
frappe (au baseball) ou encore des leçons
sur l’accélération.

Cartes Micro:bit qui fait de la musique a. Idées | micro :bit. (s. d.). Consulté 29 mars 2017, à
(stage 2018) l’adresse [Link]

P ROGRAMMER LA CAR TE Micro:bit par blocs

Une interface en ligne
L’interface de programmation par blocs a été développée en partenariat avec microsoft, elle se
trouve en ligne à cette adresse : [Link]
Il s’agit donc d’une page internet mais dont le code est mis en cache par le navigateur ce qui si-
gnifie qu’elle reste opérationnelle hors ligne.

R EMARQUE
À partir de chrome par exemple, il est possible de créer un raccourci sur le bureau.

8
Un simulateur !
Le très gros intérêt de cette interface consiste en son simulateur de carte qui permet d’avoir un
aperçu du fonctionnement du programme avant même de le télécharger sur la carte.

Interface de programmation par bloc qui intègre un simulateur

R EMARQUE
Le simulateur peut ne pas fonctionner hors ligne.

Compilation et enregistrement
Le téléchargement sur la carte se fait très simplement puiqu’elle est reconnue comme une clé USB.
Il suffit donc de cliquer sur Télécharger et de copier le fichier obtenu (.hex) sur la carte.

Programmation par bloc

Comme toute interface de programmation par blocs, elle est très intuitive à manipuler. Les premiers
programmes se font très simplement et les catégories sont classées par couleurs et par technicité.

R EMARQUE
L’interface propose aussi de programmer en javascript, il suffit juste de cliquer sur un bou-
ton pour changer de type de programmation.

Documentation
— Une page de documentation présente les éléments de base pour la programmation par blocs
[Link]
— Une page de références présentent quelques fonctionnalités propre au microbit
[Link]

P ROGRAMMER LA CAR TE Micro:bit EN Python

Le Micro:bit peut exécuter une version allégée de Python qui s’appelle MicroPython. C’est une
version spécialement dédiée aux microcontroleurs.

9
Une interface en ligne
Il est possible de programmer en python à partir d’un éditeur en ligne [Link]
L’interface est cependant assez pauvre en fonctionnalité et ne dispose pas de l’autocomplétion.

Interface de programmation en ligne

Mu : une interface complète

Comme le dit (en anglais) la page d’accueil de Mu : Mu est un éditeur de code simple pour les
programmeurs débutants. Il est développé en Python et fonctionne sur Windows, OSX, Linux et Rasp-
berry Pi.

Interface de programmation Mu

Programmation
L’autocomplétion et l’autoindentation est très efficace. L’interface est rapidement utilisable par un
débutant en programmation. Compilation et enregistrement
Le téléchargement sur la carte se fait très simplement puisqu’il suffit de cliquer sur le bouton Flash . Il
est tout de même préférable d’avoir au préalable le réflexe de vérifier le code avec Check .

Communication série
La fonction REPL de Mu permet d’ouvrir une communication via un port série avec le Micro:bit. Il
est ainsi possible d’envoyer et de recevoir des données. Sur les versions bêta il y a même un plotteur
qui permet de visualiser graphiquement les données reçues.

10
Documentation
Il est existe un documentation sur microbit et micropython, qui bien qu’en anglais reste très acces-
sible.
[Link]

11
Mémo : les blocs principaux Micro:bit

Dans cette catégorie, on trouve les deux blocs essentiels qui sont
d’ailleurs présents par défaut à l’ouverture d’un nouveau projet.
— Le bloc "au démarrage" permet d’initialiser un programme, la
séquence d’instruction qui y sera placée ne sera donc exé-
cuté qu’une seule fois.
— Le bloc "toujours" contient la séquence d’instruction qui sera
perpétuellement exécutée par le processeur.
— Outre ces blocs, vous trouverez dans cette catégorie les élé-
ments permettant d’afficher des figures, du texte, d’effacer
l’écran, de faire une pause, etc ...

La catégorie "Entrées" proposent notamment des blocs "Lorsque"

qui fonctionnent de la même façon que le bloc "Toujours", à la dif-
férence que le Micro:bit est ici en perpétuelle attente d’un évè-
nement, que ce soit l’appui sur un bouton, un geste ou l’activation
d’une broche.

On y trouve aussi les blocs permettant de recueillir les données :

— savoir si un bouton est pressé ;
— connaître la mesure de l’accélération ;
— relever la température (du processeur) ;

Les fonctions de communication du Micro:bit se trouve dans cette

catégorie.
Les données envoyées (nombre et/ou chaîne de caractères) ne
sont pas "routées" : les reçoivent qui peut. Pour filtrer les réceptions il
est possible de définir des groupes.

Les blocs de "réception" se comportent comme des blocs d’en-

trées et attendent perpétuellement un événement.

12
Cette catégorie contient les blocs permettant de faire des boucles
ils sont aux nombres de 4 :
— "répéter", qui est le plus simple et qui convient dans un grand
nombre de cas ;
— "tant que", qui répète la séquence tant que la condition indi-
quée est vraie ;
— "pour" qui répète une séquence en incrémentant une valeur
entière ou un index de liste ;

Dans la catégorie "Logique" nous allons trouver les blocs relatifs aux
instructions conditionnelles, aux tests et au booléens
— Les blocs conditionnels permettent d’exécuter une suite d’ins-
truction si le résultat d’un test donné est [Link] modifie le
nombres de conditions en cliquant sur + ou -.
— Les blocs de test permettent de comparer des nombres, des
chaînes de caractères, des booléens...
— Les blocs booléens permettent d’effectuer des opérations lo-
giques.

Par défaut, cette catégorie est vide tant qu’aucune variable n’a
été définie, ou qu’aucun bloc comprenant une variable par dé-
faut n’a été utiliser.
Une variable peut bien sûr contenir un nombre, un booléen, une
chaîne de caractères, une liste...
— Le bloc "définir" permet d’affecter une valeur à la variable.
— Le bloc "changer par" consisite à incrémenter la valeur de la
variable

Vous trouverez dans cette catégorie tous les blocs pour les opé-
rations classiques, mais aussi les blocs permettant de générer de
l’aléatoire, ou encore de contraindre ou mapper des valeurs.

13
Pour accéder à cette catégorie, il faut dérouler le menu

.
Tout comme pour la catégorie "Variables", il faut définir au préa-
lable une fonction pour voir apparaître le bloc correspondant.

Une fonction peut être définie avec ou sans paramètres d’entrées.

Une fonction en bloc ne renvoie pas de valeur.
Une fois la fonction définie, on dispose d’un bloc pour l’appeler.

14
Ton premier programme avec Micro:bit

D ESCRIPTION
Objectif
Une minute top chrono !
Il vous faudra un peu plus de temps (mais à peine) pour réaliser ce premier programme,
qui vous permettra de simuler un sablier. Ou alors d’égréner le temps qui passe durant ce
cours interminable.
Voilà de bons prétextes pour découvrir les possibilités offertes par Micro:bit !

Intérêt
découvrir l’interface de programmation et élaborer son premier programme ;
découvrir quelques fonctions pour avoir envie d’en savoir plus ;
programmer un objet très facilement.

Matériel

— 1× Micro:bit (mais un accès internet peut suffir)

— 1 × accès internet : IDE programmation par bloc [Link]

Pour commencer
— Se munir d’un Micro:bit et de son cable usb ;
— Brancher un Micro:bit sur l’ordinateur ;
— Ouvrir un navigateur internet récent et aller sur la page citée au-dessus.

— Cliquer sur

Prise en main
Lors du démarrage d’un nouveau projet, l’interface place par défaut dans
l’espace de travail les blocs au démarrage et toujours ; or nous n’avons
pas besoin de ce dernier pour notre projet. Pour s’en débarrasser il suffit de
le saisir et le lâcher vers la gauche, au dessus du menu des catégories.

15
Description
Pour construire le programme, il suffira par la suite de sélectionner les blocs
adéquats parmi les catégories et de les enclencher pour créer des sé-
quences d’instructions.

Définition du programme
Nous voulons programmer un Micro:bit qui :

— allume toutes les LED lorsqu’on le secoue ;

— éteigne les LED une par une à intervalle régulier ;
— éteigne toutes les LED en 1 minute Micro:bit.

Nous allons trouver les blocs nécessaires dans les catégories suivantes :

Pour l’initialisation et l’affichage.

Pour l’interaction avec les boutons.

Pour interagir avec chaque LED.

Pour répéter des instructions.

Pour repérer les LED.

Création du programme
Voilà une proposition de programme pour réaliser notre objet :

Il ne vous reste plus qu’à le télécharger. Le fichier sera compilé sous le nom [Link] et se
retrouvera sur votre ordinateur dans votre dossier des téléchargements.
Pour flasher le Micro:bit avec, il suffit de déplacer ce fichier vers la carte, qui doit être reconnue
comme un lecteur USB par votre gestionnaire de fichiers.

R EMARQUE

Si vous utilisez le navigateur Chrome ®, il est possible d’appairer le Micro:bit (protocole

webUSB) afin de téléverser le code directement sur la carte ce qui évite d’avoir à télé-
charger le fichier compilé puis à le copier manuellement.

16
Description
Explication du programme
Dans ce programme, la principale difficulté consiste à éteindre les LED une
par une.
Il faut savoir que les LED sont repérées par leur abscisse (x) et leur ordon-
née (y).
La LED de coordonnées (0,0) est située en haut à gauche et la LED de co-
ordonnées (4,4) est située en bas à droite.

Nous allons donc utiliser ces paramètres dans des boucles "pour" imbriquées. Une boucle va par-
courir les valeurs de x, et l’autre les valeurs de y.
La boucle "pour" utilise une variable (par exemple "i" ou "index") qui est
créée automatiquement lorsqu’on utilise ce bloc.

Nous avons besoin de deux variables : une pour les valeurs de x, l’autre
pour les valeurs de y.
Il faudra donc en créer une nouvelle (par exemple "j") pour parcourir les
valeurs de y.

Puisque la durée est fixée à 1 minutes, c’est à dire 60 000 millisecondes et qu’il y a 25 LED, avant
chaque extinction de LED il faut faire une pause d’une durée de 60000 25 = 2400 millisecondes.

17
 Commande de base pour Micro:bit (et
python)

D ESCRIPTION
Objectif
Il est possible de programmer la carte Micro:bit avec Python. Pour cela, il faut utiliser le
module Micro:bit.
Dans cette fiche, vous découvrirez les commandes essentielles de ce module.

Matériel

— 1× Micro:bit
— 1 × IDE programmation python (Mu) : à télécharger/installer en https ://[Link]/

C OMMANDES ESSENTIELLES

Durée Public Maths Sciences Algo

affichage ;
2h 2de bouton ;
événement.

Le module microbit
En Python, les entrées/sorties de la carte Micro:bit ne sont pas nativement accessibles. Afin de
pouvoir utiliser les fonctions prévues à cet effet, il faut appeler le module microbit .
Pour appeler ce module, il faut utiliser la commande classique from ... import ...

M ÉTHODE

from microbit import *

Astuce
La bibliothèqe microbit est déjà téléchargée et préinstallée avec le logiciel mu-editor. Mais il
faut tout de même l’appeler pour l’utiliser

Le module micropython introduit des classes (avec instances, méthodes et propriétés) et des mo-
dules (avec fonctions et constantes).

18
Commandes essentielles
Exemple de classes : Exemple de modules :
Image pour créer et manipuler les images. Les display pour gérer l’écran de LED
propriétés sont des images déjà enregistrées accelerometer pour interroger l’accéléromètre
(comme les smileys)
compass pour manipuler et interroger la boussole
Button avec deux instances button_a et button_b
pour connaître l’état des boutons. music pour créer et manipuler de la musique
Pin avec différentes instances en fonction du speech pour faire parler le Micro:bit
type de broche (digitale, analogique ou de radio pour communiquer entre Micro:bit via un
contact comme pin0, pin1 et pin2). protocole simple

R EMARQUE
Pour aller plus loin, vous pouvez consulter la page Microbit Module de la documentation
officielle.

Micropython dans la carte Micro:bit

Lorsque la carte Micro:bit est flashée avec le module microbit , elle contient un noyau micropy-
thon et peut donc exécuter du code python.
L’IDE Mu permet d’accéder au noyau micropython de la carte. Pour accéder au terminal de ce
noyau, il suffit de cliquer sur l’icône REPL de l’application.
Il est alors tout à fait possible d’écrire du code dans ce terminal qui sera exécuté par la carte Micro:bit.

R EMARQUE
L’instruction print() permet d’écrire dans le terminal REPL.

M ÉTHODE
Pour utiliser le terminal de la carte Micro:bit :
— Flasher la carte Micro:bit avec micropython.
— Ouvrir le terminal de la carte en cliquant sur REPL
— saisir le code ci-dessous :
> print("Hello, World!")

M ÉTHODE
Le programme ci-dessous affiche 10 fois le même texte dans le terminal :

from microbit import *

for i in range(10):
print("Hello, World!")

Afficher un texte
Le module display permet de gérer l’écran de LED de Micro:bit.

La fonction [Link]("string") permet d’afficher un texte.

La fonction [Link]("string") permet de le faire défiler.

19
Commandes essentielles
M ÉTHODE

from microbit import *

[Link]("Hello,")
[Link]("World!")

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Hello, World! et Display
de la documentation officielle.

Des images
La classe Image contient comme propriétés de nombreuses images pré-programmées. Par exemple
l’image du coeur : [Link]

Pour afficher une image, il faut utiliser la fonction [Link]() . La fonction [Link]()
permet d’effacer l’écran.
Pour afficher successivement des images, il faut mettre le Micro:bit en pause. Sinon l’utilisateur n’aura
pas le temps de tout voir. La commande sleep(nombreEntier) arrête donc la carte pendant la
durée (en milliseconde) indiquée.

M ÉTHODE
Le code Python ci-dessous affiche une image pendant une seconde puis affiche une
deuxième image. Une seconde plus tard, l’écran s’efface.

from microbit import *

[Link]([Link])
sleep(1000)
[Link]([Link])
sleep(1000)
[Link]()

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Images ou Image de la
documentation officielle.

Des animations
Lorsque plusieurs images sont stockées dans un tableau, il est possible de les faire défiler à un rythme
donné. Ceci permet de facilement créer une animation.
Pour faire défiler des images, utiliser l’option delay=nombreEntier de la fonction [Link]() .

Le module microbit contient deux tableaux d’images :

20
Commandes essentielles
— Image.ALL_CLOCKS qui affiche la grande aiguille d’une montre sous différentes orientations
— Image.ALL_ARROWS qui affiche des flèches dans toutes les directions.

M ÉTHODE
Le code ci-dessous affiche toutes les 0,200 secondes l’aiguille d’une montre qui tourne :

from microbit import *

[Link](Image.ALL_CLOCKS, delay=200)

R EMARQUE
Pour aller plus loin, vous pouvez consulter la page Introduction » Images de la documen-
tation officielle.

Des boutons
Les états des boutons de la carte Micro:bit sont récupérables par le module micropython . Il existe
pour cela deux classes : button_a et button_b .
Ces deux classes possèdent 3 méthodes :
— .get_presses() retourne le nombre de fois que le bouton a été pressé depuis le dernier ap-
pel de cette méthode
— .is_pressed() retourne un booléen qui indique si le bouton est actuellement pressé

— .was_pressed() retourne un booléen qui indique si le bouton a été pressé depuis le dernier
appel de cette méthode.

M ÉTHODE
Le code ci-dessous affiche le nombre de fois que le bouton A a été pressé depuis le dé-
marrage.

from microbit import *

sleep(10000)
[Link](str(button_a.get_presses()))

Pour programmer un Micro:bit, il est très souvent nécessaire de détecter un évènement comme
par exemple l’appui sur un bouton.
Une méthode simple consiste à créer une boucle infinie while True: contenant un test qui, à
chaque itération de la boucle, vérifie la réalisation de l’évènement attendu.
Lorsque l’événement se réalise, l’instruction break est appelée pour sortir de la boucle.

M ÉTHODE
Le code ci-dessous tourne en boucle.
— Lorsque aucun évènement n’est détecté, c’est l’image triste [Link] qui s’af-
fiche.
— Pendant que le bouton A est pressé, l’image joyeuse [Link] s’affiche.
— Pendant que la broche pin1 est touchée (en même temps que la broche GND),
l’image endormie [Link] s’affiche.
— Lorsque le bouton B est pressé, l’écran s’efface et le programme quitte la boucle.

21
Commandes essentielles

from microbit import *

while True:
if button_a.is_pressed():
[Link]([Link])
elif pin1.is_touched():
[Link]([Link])
elif button_b.is_pressed():
[Link]()
break
else:
[Link]([Link])

R EMARQUE
Les broches instanciées pin0 , pin1 et pin2 peuvent aussi servir de bouton. La mé-
thode .is_touched() permet de renvoyer un booléen qui devient vrai lorsqu’une per-
sonne en contact avec la masse (broche GND) touche puis relâche la broche en question.
En effet, lorsqu’une instance de ces broches est activée, la carte Micro:bit mesure la
résistance entre cette broche et la masse (broche GND). Lorsque cette dernière varie et
passe d’une valeur quasi infinie à une valeur faible, le test devient vrai. Cet évènement
arrive lorsqu’une personne en contact avec GND touche la broche et la relâche.

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Boutons et Buttons de
la documentation officielle.

Le hasard
Le module random est utilisable avec Micro:bit. Une fois importé, il est très simple de générer des
nombres aléatoires avec les fonctions [Link]() ou [Link](a,b) .

M ÉTHODE
Le programme ci-dessous affiche très rapidement 50 nombres aléatoires tirés entre 1 et 6.
Le dernier nombre tiré est affiché pendant une seconde puis effacé.

from microbit import *

import random
for i in range(50):
[Link]([Link](1, 6))
sleep(20)
sleep(1000)
[Link]()

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Hasard et Random
Number Generation de la documentation officielle.

Le mouvement
L’accéléromètre du Micro:bit est accessible par le module accelerometer .

22
Commandes essentielles
Il est alors possible de récupérer une des coordonnées du vecteur accélération (avec une fonction
du type accelerometer.get_x() .

M ÉTHODE
Le programme ci-dessous affcihe une flèche en fonction de l’inclinaison du Micro:bit.
Le bouton B permet de quitter cette boucle.

from microbit import *

button_b.was_pressed()
while True:
capteur = accelerometer.get_x()
if capteur > 40:
[Link](Image.ARROW_E)
elif capteur < -40:
[Link](Image.ARROW_W)
else:
[Link]("-")
if button_b.was_pressed():
[Link]()
break

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Mouvement et Accele-
rometer de la documentation officielle.

Les gestes
Le module accelerometer peut aussi détecter des mouvements ou des positions pré-programmés :
les gestes ("up", "down", "left", "right", "face up", "face down", "freefall", "3g", "6g", "8g", "shake").
Il y a alors 3 fonctions qui s’applique sur le module accelerometer :
— accelerometer.get_gestures() retourne un tuple contenant l’historique des gestes. Le dernier
élément du tuple est le geste le plus ré[Link] tuple est réinitialisé à chaque appel de cette
fonction.
— accelerometer.is_gesture("nom") retourne un booléen qui indique si le geste en cours est
"nom" .
— accelerometer.was_pressed("nom") retourne un booléen qui indique si le geste "nom" a été
pressé depuis le dernier appel de cette fonction.

M ÉTHODE
Le programme ci-dessous affiche le nombre "8"
Lorsque le Micro:bit est secoué, il s’affiche une seconde plus tard de manière aléatoire
et équiprobable soit "Oui", soit "Non".
Le jeu recommence sauf si on appui sur le bouton B ce qui fait sortir de la boucle.

23
Commandes essentielles

from microbit import *

import random
button_b.was_pressed()
while True:
[Link]("8")
if accelerometer.was_gesture("shake"):
[Link]()
sleep(1000)
[Link]([Link](["Oui","Non"]))
if button_b.was_pressed():
break

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Gestes et Accelerome-
ter de la documentation officielle.

La radio
Les cartes Micro:bit peuvent communiquer entres elles au moyen du module radio .
La fonction [Link]("string") permet d’envoyer par radio le texte "string" .

La fonction [Link]() retourne la chaîne de caractère des données reçus par radio. Si rien
n’a été reçu, la chaine vaut None

M ÉTHODE
Le programme est à téléverser sur 2 cartes Micro:bit. Un appui sur les boutons A ou B de
l’un des Micro:bit affiche les texte "A" ou "B" sur l’autre.

from microbit import *

import radio
import random

button_a.was_pressed()
button_b.was_pressed()

while True:
# émetteur
if button_a.was_pressed():
[Link]("A")
if button_b.was_pressed():
[Link]("B")

# récepteur
incomming = [Link]()
if incomming == "A":
[Link]("A")
if incomming == "B":
[Link]("B")

# sortir de la boucle
if pin0.is_touched():
[Link]()
break
sleep(20)

24
Commandes essentielles
R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Radio et Radio de la
documentation officielle.

La boussole
Pour interroger la boussole du Micro:bit, il faut utiliser le module compass .

Certaines fonctions comme [Link].get_x() renvoient une composante du vecteur

champ magnétique.
La fonction [Link]() renvoie l’angle en degré entre l’orientation de la carte
Micro:bit et le nord magnétique.

R EMARQUE
Avant d’utiliser une fonction du module compass , il faut obligatoirement calibrer
Micro:bit.
Pour cela, il est automatiquement demandé à l’utilisateur de bouger la carte dans diffé-
rentes positions. Il faut que le point rouge qui clignote passe par toutes les LED de l’écran.
Pour programmer une calibration de la carte, il est possible d’utiliser la commande
[Link]() .

M ÉTHODE
Le programme ci-dessous fait office de boussole et indique le nord magnétique.
Attention, le capteur est sensible aux objets tels que téléphones, ordinateurs ou aux lieux
tels que ascenseurs ou salle informatique. . .

from microbit import *

[Link]()
button_b.was_pressed()
while True:
cap = ((15 - [Link]()) // 30) % 12
[Link](Image.ALL_CLOCKS[cap])
if button_b.was_pressed():
[Link]()
break

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Direction et Compass
de la documentation officielle.

25
Des commandes pour aller plus loin

D ES COMMANDES POUR ALLER PLUS LOIN

Durée Public Maths Sciences Algo

affichage ;
bouton ;
2h 2de
événement ;
son

Représentation graphique avec Mu

Il est possible de tracer un nuage de points avec l’IDE Mu.
Pour cela, il faut
— utiliser l’outil Graphique de l’IDE Mu,
— faire afficher par le programme en cours d’exécution un tuple de nombres.

M ÉTHODE
Le programme ci-dessous affiche dans le terminal (ou dans le Graphique si l’outil de l’IDE
est cliqué) des fréquences d’apparitions lors d’une expérience aléatoire.

from microbit import *

import random
while True:
if button_a.was_pressed():
nb1 = 0
total = 0
for i in range(1000):
# tirage aléatoire
tirage = [Link](0,1)
total = total + 1
# calcul d'effectifs
nb1 = nb1 + tirage
nb0 = total - nb1
# affichage dans le terminal
print((i, nb1/total, nb0/total))

Des images personnalisées

Les images sont des objets qui peuvent être créées grâce au constructeur Image("string") .

Le texte "string" permet de décrire, ligne par ligne, la luminosité de chaque pixel de l’écran de
LED. Pour chaque diode, la valeur varie de 0 (éteinte) à 9 (luminosité maximale). Pour séparer les
lignes, il faut utiliser le symbole ":"

M ÉTHODE
Voici une image représentant un bateau avec la coque plus foncée que les 2 mâts :

26
Des commandes pour aller plus loin

from microbit import *

bateau = Image("05050:"
"05050:"
"05050:"
"99999:"
"09990")
[Link](bateau)
sleep(1000)

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Images ou Image de la
documentation officielle.

Des animations personnalisées

En stockant des images personnalisées dans un tableau, il est possible de créer des animations per-
sonnalisées.

M ÉTHODE
Créer un image représentant un tableau et stocker cette image dans la variable
bateau1 :

from microbit import *

bateau1 = Image("05050:"
"05050:"
"05050:"
"99999:"
"09990")

Créer d’autres images (donnant l’illusion que le bateau s’enfonce) et les stocker dans de
nouvelles variables :

bateau2 = Image("00000:"
"05050:"
"05050:"
"05050:"
"99999")

bateau3 = Image("00000:"
"00000:"
"05050:"
"05050:"
"05050")

bateau4 = Image("00000:"
"00000:"
"00000:"
"05050:"
"05050")

bateau5 = Image("00000:"
"00000:"
"00000:"
"00000:"
"05050")

27
Des commandes pour aller plus loin

bateau6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

Créer un tableau regroupant toutes les images et afficher l’animation :

tous_bateaux = [bateau1, bateau2, bateau3, bateau4, bateau5, bateau6]

[Link](tous_bateaux, delay=200)

R EMARQUE
Pour aller plus loin, vous pouvez consulter la page Introduction » Images de la documen-
tation officielle.

Faire parler Micro:bit

La carte Micro:bit peut aussi parler. Avant cela, il faut connecter un casque audio ou un (petit)
haut-parleur à la carte.

Le module speech contient les fonctions permettant de gérer la voix de Micro:bit, dont la fonc-
tion [Link]("string") qui fera parler.

M ÉTHODE

from microbit import *

import speech
[Link]("Hello, World")

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Speech ou Speech de
la documentation officielle.

De la musique
La carte Micro:bit est capable de jouer de la musique. Pour cela, il faut au préalable connecter un
casque audio ou un petit haut-parleur à la carte.

28
Des commandes pour aller plus loin

Le module music contient les fonctions permettant de gérer et de contrôler le son. Parmi elles, la
fonction [Link]() joue une mélodie.

Par ailleurs, le module music contient aussi un grand nombre de mélodies enregistrée (ie. déjà
programmées) comme par exemple :
— [Link],
— [Link] ou encore
— [Link].

M ÉTHODE
Voici comment jouer la musique POWER_UP avec Micro:bit :

from microbit import *

import music
[Link](music.POWER_UP)

La carte Micro:bit peut aussi générer un son en fonction de sa fréquence. Pour cela, il faut utiliser
la fonction [Link](freq, duree) qui va générer pendant duree millisecondes le son de
frequence freq .

M ÉTHODE
Le code ci-dessous génère une sirène qui passe d’un son grave à un son aigu puis qui re-
devient grave.
Chaque fois que le son redevient grave, la boucle teste si le bouton B a été pressé. Si
c’est la cas, le programme quitte la boucle.

from microbit import *

import music
button_b.was_pressed()
while True:
for freq in range(880, 1760, 16):
[Link](freq, 6)
for freq in range(1760, 880, -16):
[Link](freq, 6)
if button_b.was_pressed():
break

M ÉTHODE
Le programme ci-dessous génère un son dépendant de l’inclinaison du Micro:bit.
Le bouton B permet de quitter cette boucle.

29
Des commandes pour aller plus loin

from microbit import *

import music
button_b.was_pressed()
while True:
ton = max(0, accelerometer.get_y())
[Link](ton, 10)
if button_b.was_pressed():
break

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Musique ou Music de la
documentation officielle.

Les fichiers
La carte Micro:bit peut stocker des fichiers. Ces derniers ne sont pas accessibles par le système
classique de fichiers, mais par l’intermédiaire de l’outil Fichier de l’IDE Mu.
Il est tout à fait possible d’utiliser Python pour lire, créer, modifier ou effacer un fichier.

M ÉTHODE
Pour lister les fichiers présents sur la carte Micro:bit, il faut utiliser le module os .
La fonction [Link]() renvoie alors une liste de chaîne de caractère. Chaque élé-
ment de la liste est un nom de fichier.

import os
listeFichiers = [Link]()

M ÉTHODE
Pour lire le contenu d’un fichier (qui doit exister), il faut :
— créer une instance de fichier en mode lecture 'r'
— utiliser la méthode .read() pour copier le contenu du fichier dans une variable.

L’exemple ci-dessous lit le fichier [Link] , copie son contenu dans la variable txt
et l’afficher dans le terminal :

with open('[Link]','r') as monFichier:

txt = [Link]()
print(txt)

M ÉTHODE
Pour écrire un texte dans un fichier (qui peut ne pas exister), il faut :
— créer une instance de fichier en mode écriture 'w'
— utiliser la méthode .write("string") pour écrire le texte dans le fichier (attention,
si le fichier existait déjà, cela supprimera tout ce que le fichier contenait).

30
Des commandes pour aller plus loin

L’exemple ci-dessous ouvre le fichier [Link] en écriture puis écrase son contenu
avec le contenu de la variable txt .

txt = "1,2,3\n4,5,6"
with open('[Link]','w') as monFichier:
[Link](txt)

M ÉTHODE
Le programme ci-dessous effectue 50 tirages aléatoires qu’il enregistre dans le fichier
[Link].

— importer tous les modules nécessaires

— sauvegarder les 50 tirages dans la variable txt
— établir la liste des fichiers
— si le fichier [Link] existe, lire le fichier et sauvegarder ses données dans la variable
contenu
— ouvrir le fichier en mode écriture et l’écraser avec le contenu mis à jour.

# sauvegarder 50 nb aléatoires
from microbit import *
import random
import os

txt = ""
for i in range(50):
nb = [Link](1, 6)
txt = txt + str(nb)
[Link](nb)
sleep(20)

# connaître la liste des fichiers sur MB

listeFichiers = [Link]()

# si le fichier '[Link]' existe, récupérer le contenu

if ('[Link]' in listeFichiers):
with open('[Link]','r') as monFichier:
contenu = [Link]()
else:
contenu = ""

with open('[Link]','w') as monFichier:

contenu = contenu + txt + "\n"
print(contenu)
[Link](contenu)

R EMARQUE
Pour aller plus loin, vous pouvez consulter les pages Introduction » Storage ou Local Per-
sistent File System de la documentation officielle.

31
 Superviser le travail des élèves sur
Micro:bit

D ESCRIPTION
Objectif
Le suivi individuel des élèves est un critère majeur de réussite d’une activité. L’interface
va permettre de superviser l’avancement de chaque élève, afin de
lui proposer un travail en rapport avec ses capacités.

Intérêt
Micro:bit |classroom est un espace de programmation partagé entre les élèves et leur enseignant.
Cet outil en ligne permet de :

proposer une situation initiale en bloc ou en python ;

suivre en direct le travail des élèves ;
partager du code entre élèves de façon globale ou ciblée ;
sauvegarder une séance de travail ;
reprendre une séance là où elle s’était arrêtée.

Matériel

— 1× Micro:bit (facultatif car le simulateur peut suffire)

— 1 × accès internet : [Link]
— navigateur Chrome®

R EMARQUE
Le parti pris de l’application est la simplicité avec ses avantages et ses inconvénients.

Avantages : Inconvénients :
— Pas de compte utilisateurs
élève/enseignant à créer. — L’identification des élèves repose sur
la confiance (possibilité d’usurpation
— Fichier unique de sauve-
d’identité lors de la reprise d’une acti-
garde/récupération pour reprendre
vité).
la session plus tard (format .html).
— Compte rendu de la session téléchar- — Pas d’éditeur de texte pour échanger
geable (format texte .docx). avec les élèves.

R EMARQUE
Attention la version présentée ici est la version beta de classroom. Les menus encore en
anglais sont amenés à évoluer (ou pas...)

32
Mode d’emploi de Classroom

M ODE D ’ EMPLOI DE C LASSROOM

Créer une Classroom

M ÉTHODE
Ouvrir le navigateur Chrome et rejoindre le site [Link] Il suffit
de donner le nom de l’activité, le type d’environnement de programmation (bloc ou py-
thon), et c’est parti.

R EMARQUE
Il est possibe de choisir si l’on souhaite autoriser l’application à enregistrer des données lo-
calement (dans le "local storage" du navigateur), à éviter si l’ordinateur est partagé mais
utile si l’on craint de perdre son travail.

Proposer un programme

M ÉTHODE
Dans le bandeau supérieur on trouve le menu de ce qui correspond aux 4 étapes de la
vie d’une session :
1) Création du code dans l’éditeur.
2) Partage de la session.
3) Supervision des travaux.
4) Sauvegarde et clôture d’une session.

33
Mode d’emploi de Classroom

Il faut donc commencer par ouvrir l’éditeur (ici pour la programmation en blocs) et écrire
un programme ou un début de programme (par exemple celui proposé par la fiche "pile
ou face").

Une fois le code terminé, il ne faut pas oublier de le partager en cliquant sur le bouton
"Share code with students".

R EMARQUE
L’éditeur comporte les mêmes fonctionnalités que sur [Link] il est
donc possible de :
— télécharger le code.
— appairer la carte Micro:bit avec le navigateur.
— ouvrir un programme compilé sous la forme d’un fichier .hex en faisant glisser ce fi-
chier dans la fenêtre de classroom.
Le code peut être modifié ultérieurement pour être distribué à toute la classe ou de fa-
çon ciblée, ce qui permet un travail de différenciation.

Partager la session

M ÉTHODE
Pour se connecter à la session, les élèves doivent aller sur le site : [Link]
join renseigner le nom de la classe (l’occasion de réviser son vocabulaire anglais) et ren-
trer le code PIN.

34
Mode d’emploi de Classroom

R EMARQUE
Une fois connectés, les élèves renseigneront leur nom tel qu’il apparaîtra sur votre écran,
mais aussi tel qu’il sera enregistré dans le fichier de sauvegarde et de compte-rendu, at-
tention aux noms fantaisistes.

Superviser les travaux

M ÉTHODE
Dans cette fenêtre, la liste des élèves apparaît à gauche avec l’indication de l’état de
son travail : en cours ou terminé (avec en prime une autoévaluation sous la forme de smi-
ley).
Dans la partie droite apparait le travail de l’élève dont les modifications sont instantanné-
ment reportées. Là encore on retrouve le bouton "Share code with students" qui permet
d’envoyer à tout ou une partie de la classe le code produit par un élève.

R EMARQUE
Pour l’éditeur de programmation par bloc, seul les blocs actifs côté élève apparaitront
dans la fenêtre de supervision.

35
Mode d’emploi de Classroom

Sauvegarder une session

M ÉTHODE
Cette dernière étape de la vie d’une session vous permettra de récupérer un fichier html
contenant toutes les informations nécessaires pour reprendre le travail ultérieurement. Le
fait de clôturer la session, rendra inactive la connexion.

Pour reprendre le travail, il suffit d’ouvrir fichier .html dans le navigateur et l’on retrouvera
le dernier programme proposé ainsi que les travaux des élèves. Ils pourront dès lors de
nouveau se connecter, et sélectionner leur nom dans un menu déroulant afin de retrou-
ver leur travail.

R EMARQUE
Attention au paramètrage du navigateur, si celui est trop strict sur la gestion des données
personnelles vous pourriez être dans l’impossibilité de réouvrir correctement une session.

36
 Borne de satisfaction avec Micro:bit

D ESCRIPTION
Objectif
Le but de ce projet est de fabriquer une borne de vote
pour un questionnaire de satisfaction. Une question est
posée et la réponse est donnée sur une échelle de trois
valeurs. Par exemple, la question pourra être

Journée Portes Ouvertes : votre avis nous intéresse !

Que pensez vous de votre visite ?

— , Très satisfaisant
— Satisfaisant
— / Non satisfaisant

Intérêt
La borne de satisfaction a été présentée et utilisée lors des journées portes ouvertes, dans nos ly-
cées.

Projet concret Les élèves visualisent rapidement le but à atteindre. Ils ont tous déjà vu une borne de
satisfaction et ils imaginent rapidement son utilité.
Motivation La journée portes ouvertes est l’occasion de représenter le lycée auprès de personnes
extérieures. Les élèves sont fiers de montrer leurs créations.
Pluridisciplinarité La création de la borne de satisfaction peut mobiliser de nombreuses disciplines
sur le lycée : maths/sciences pour la conduite du projet, mathématiques pour l’exploitation
des résultats, mode-vêtement et maroquinerie pour la décoration, arts appliqués pour les vi-
suels ou encore bois, plasturgie et métallurgie pour la boite.

Matériel

— 1× Micro:bit
— 1 × accès internet : IDE programmation par bloc [Link]

— 1 boite (carton, bois, métal, etc.)

— 4 câbles électriques + 4 pinces crocodiles
— 1 rouleau de papier aluminium

37
Niveau initiation - Premier modèle

N IVEAU INITIATION - P REMIER MODÈLE

Activité élève

Durée Public Maths Sciences Algo

boucle ;
1h 2de
évènement

ACTIVITÉ
La Journée Portes Ouvertes aura lieu dans 1 mois !
Nous souhaitons créer une borne de satisfaction.

Ta Mission : Programme Micro:bit pour simuler une borne de vote.

Ta mission doit respecter les contraintes suivantes :

lorsque le bouton A est pressé une animation de type non satisfaisant apparaît
lorsque le bouton B est pressé une animation de type très satisfaisant apparaît
après chaque animation afficher un petit mot de remerciement

38
Niveau initiation - Premier modèle
Notes pour l’enseignant

M ÉTHODE
Proposition de résolution :

R EMARQUE
Une proposition de code accessible en ligne [Link]

39
Niveau expert - Cumuler les votes

N IVEAU EXPER T - C UMULER LES VOTES

Activité élève

Durée Public Maths Sciences Algo

boucle ;
1h 2de effectifs évènement ;
variables

ACTIVITÉ
Bravo ! Tu as réussi à simuler une borne de vote à 2 choix : satisfaisant
ou non-satisfaisant.
Notre borne finale sera légèrement différente :
— la borne aura 3 choix de votes possibles : non-satisfaisant ; satisfaisant ; très satisfai-
sant
— la borne enregistrera les réponses de chaque vote.

Ta Mission : (re)Programme Micro:bit pour simuler la borne de vote finale.

Modifie ton code précédent :

lorsque la broche p0 est pressée
afficher une animation de type non satisfaisant
afficher un mot de remerciement
incrémenter la variable n0
lorsque la broche p1 est pressée
afficher une animation de type satisfaisant
afficher un mot de remerciement
incrémenter la variable n1
lorsque la broche p2 est pressée
afficher une animation de type très satisfaisant
afficher un mot de remerciement
incrémenter la variable n2
lorsque le bouton A est pressé afficher les valeurs des variables n0, n1 et n2

40
Niveau expert - Cumuler les votes
Notes pour l’enseignant

M ÉTHODE
Proposition de résolution :

R EMARQUE
Une proposition de code accessible en ligne [Link]

41
 Les fractions avec Micro:bit

D ESCRIPTION
Objectif

Le but de ce projet est :

cycle 4 Utiliser diverses représentations d’un même nombre ; passer d’une représentation
à une autre.
Comparer, ranger, encadrer des nombres rationnels.
CAP Comparer, additionner, soustraire, multiplier et diviser les nombres en écriture frac-
tionnaire dans des situations simples.

Intérêt
Les fractions posent en général des difficultés aux élèves et la majorité font des blocages hérités des
années antérieures. Le risque de démobilisation est grand et l’usage d’un objet connecté permet
de dédramatiser la séance.

Aspect ludique L’usage de l’affichage LED du micro :bit rend l’activité ludique. Les élèves sont pour
la plupart attirés par le côté simple et sympathique de l’écran, ce qui les poussent à réfléchir
et s’investir.
Proportions Afficher une image conforme à une contrainte est un problème concret qui permet
de mieux matérialiser un calcul de proportion, par rapport à un énoncé classique (type statis-
tiques). En évaluation, il y a plus de réponses justes quand la question repose sur un affichage
d’image que sur une situation plus habituelle (point vérifié en classe).
Plusieurs de méthodes de résolutions Il y a de nombreuses façons d’arriver aux solutions. Par exemple
pour éclairer 25 des LED, on peut d’abord faire des paquets de 5, en allumer 2 puis recommen-
cer ; soit éclairer 2 colonnes sur les 5 existantes.

Matériel

— 1× Micro:bit (facultatif car le simulateur peut suffire, même si on perd un peu sur
l’aspect ludique.)
— 1 × accès internet : IDE programmation par bloc [Link]

42
Écrire une fraction

É CRIRE UNE FRACTION

Activité élève

Durée Public Maths Sciences Algo

représentation
0,5 h Cycle 4 ; CAP d’un nombre ;
fraction

ACTIVITÉ
Écrire la proportion de LED allumée sur chaque micro:bit

Notes pour l’enseignant

Attendus :

— Les élèves écrivent les fractions correspondant pour chaque appareil.

1 5
— Lorsque c’est possible, on écrit la fraction sous différentes formes : 5 ou 25 .
— On écrit alors les conditions d’égalité de deux fractions.

R EMARQUE
Prolongement possibles :
— Répondre par une phrase : il y a 5 LED allumées sur un total de 25.
— Pour chaque cas, indiquer la proportion de LED éteintes.

43
Afficher une fraction

A FFICHER UNE FRACTION

Activité élève

Durée Public Maths Sciences Algo

représentation
0,5 h Cycle 4 ; CAP d’un nombre ; affichage
fraction

ACTIVITÉ
Représenter les fractions suivantes avec les LED du micro:bit
1 32
;
2 100

Notes pour l’enseignant

Attendus :

— Les élèves constatent qu’il n’est pas possible d’afficher un demi, on peut alors leur suggérer
d’afficher la 13ème led en alternance ou de lui réduire la luminosité.
— Les élèves doivent simplifier la deuxième fraction pour afficher, on peut alors faire le lien avec
les pourcentages

44
Somme de fractions

S OMME DE FRACTIONS
Activité élève

Durée Public Maths Sciences Algo

représentation
0,5 h Cycle 4 ; CAP d’un nombre ; affichage
fraction

ACTIVITÉ
Représenter les fractions suivantes avec les LED du Micro:bit:
2 3 23
+ ;
5 25 25

Notes pour l’enseignant

R EMARQUE
Plusieurs raisonnements sont à construire :
— créer des paquets de 5 et prendre à chaque fois 2 éléments
— diviser le tout en 5 paquets et en prendre 2

45
 Dé à 6 faces avec Micro:bit

D ESCRIPTION
Objectif

Le but de ce projet est de simuler une expérience aléatoire de lancer de dé à 6 faces

avec une carte Micro:bit.
Toujours à partir d’une situation simple idéale, le programme peut être étoffé au gré des
besoins. Il s’agit de prolonger les quelques notions utilisées pour l’activité pile ou face,
notamment lorsqu’il faudra tester les différentes issues et proposer une sortie en consé-
quence.

Intérêt
L’intérêt de cette activité n’est pas seulement de se départir des bruits des dés qui roulent dans la
classe ; l’usage du Micro:bit est ici très pertinent, tant pour les probabilités que pour la programma-
tion.
Simplicité de la situation. La situation est très simple à expliquer et les élèves comprennent le but à
atteindre. L’absence de difficulté mathématique rend cette situation particulièrement simple à
mettre en œuvre.
Motivation des élèves. L’envie de programmer un objet connecté est grande pour les élèves. Cette
façon de programmer, utile, concrète et appliquée, leur correspond parfaitement.
De nombreuses solutions/améliorations possibles. Comme pour bien des projets, il y a plusieurs fa-
çons d’arriver à la solution ; mais par rapport à l’activité Pile ou Face il y aussi plus de possibilité
de faire des erreurs de programmation.
Travail mathématique sur la modélisation. La modélisation d’un dé non truqué est évidente, et
n’apporte pas de difficulté majeure. Par contre l’intérêt majeur du Micro:bit est d’offrir la pos-
sibilité de truquer le dé. On a alors une situation beaucoup plus riche, tant dans la modélisa-
tion que dans les usages du modèle obtenu.

Matériel

— 1× Micro:bit (facultatif car le simulateur peut suffire)

— 1 × accès internet : IDE programmation par bloc [Link]

46
Niveau simple

N IVEAU SIMPLE
Activité élève

Durée Public Maths Sciences Algo

expérience affichage ;
0,25 h 2de
aléatoire événement.

ACTIVITÉ
Mission Utilise Micro:bit pour simuler un dé à 6 faces !
En t’aidant des blocs ci-dessous, programme Micro:bit pour :
1) programmer un événement lorsque l’appareil est secoué ;
2) afficher un nombre entier aléatoire entre 1 et 6.

Notes pour l’enseignant

Ce premier niveau aucun niveau de difficulté, on pourrait dire que son intérêt se limite à poser la
problématique.

M ÉTHODE R EMARQUE
Pour résoudre ce problème, il suffit de pro- Plus d’informations sur la page de l’activité :
grammer les instructions de la façon sui- [Link]
vante : latest/decouverte/[Link]

47
Niveau intermédiaire

N IVEAU INTERMÉDIAIRE
Activité élève

Durée Public Maths Sciences Algo

affichage ;
expérience
0,5 h 2de événement ;
aléatoire
condition

ACTIVITÉ
Utilise Micro:bit pour simuler un dé à 6 faces !
En t’aidant des blocs ci-dessous, programme Micro:bit pour :
1) programmer un événement lorsque l’appareil est secoué ;
2) afficher une face de dé selon le résultat d’un tirage aléa-
toire.
Attention tous les blocs ne sont pas représentés et certains blocs
doivent être modifiés.

48
Niveau intermédiaire
Notes pour l’enseignant
Pour arriver au résultat escompté il est nécessaire d’utiliser une variable, ainsi qu’une suite d’instruc-
tion si/sinon si/sinon. Si l’usage d’une variable n’apparaît pas forcément évident pour les élèves,
on peut les laisser programmer sans pour qu’il puisse ainsi constater le bug produit. Il est aussi inté-
ressant de faire remarquer aux élèves que le nombre issue du tirage aléatoire n’a pas forcément à
être celui symbolisé par sortie sur l’écran de DEL.
Le programme à assembler est disponible en suivant ce lien :
[Link]

M ÉTHODE R EMARQUE
Pour résoudre ce problème, il suffit de pro- Il est très simple en partant de cette situa-
grammer les instructions de la façon suivante tion d’envoyer les résultats par radio ver un
(seules les sorties correspondant à 1 et à 6 Micro:bit qui centraliserait alors les issues
ont été incluses, pour raison de place) : de l’ensemble des tirages. Pour cela il suffit
d’ajouter le bloc "envoyer le nombre" qui se
trouve dans la catégorie "Radio".

49
 Normal ou truqué ? avec Micro:bit

D ESCRIPTION
Objectif

Cette activité propose à l’élève de travailler sur la fluctuation d’échantillonnage.

Sans accéder au code, seulement en manipulant la carte Micro:bit, l’élève doit déter-
miner si le jeu téléversé est un jeu normal ou truqué. . .

Intérêt
L’intérêt de cette activité est de pouvoir, en toute liberté, créer des situations équiprobables ou non.
Même s’il est possible d’utiliser de vrais dès truqués, l’utilisation d’une carte Micro:bit permet un
éventail très larges de situations.
Ici le choix a été fait de procéder à un tirage aléatoire (ou non ;) ) d’un nombre entre 0 et 9 (inclus).

Matériel

— 1× Micro:bit (facultatif car le simulateur peut suffire)

— 1 × accès internet : IDE programmation par bloc [Link]

Progression
L’activité se déroule en 2 temps :
Analyse du programme Dans cette partie, l’élève doit étudier les deux programmes possibles (tru-
qué ou non) puis répondre à une série de questions de probabilités
Expérience aléatoire Ensuite l’élève manipule la carte Micro:bit et effectue un certain nombre
d’expériences aléatoires. Dans cette partie l’analyse des échantillons et la création d’une re-
présentation graphique permettra de conclure sur le type de programme téléversé.

50
Activité

ACTIVITÉ
Activité élève

Durée Public Maths Sciences Algo

fluctuation
2h 2de ; term
d’échantillage

ACTIVITÉ
Normal ou truqué ?
Sur votre carte est téléversé un des deux programmes de jeu suivant.
Quand le joueur gagne, il a un smiley sourire, sinon il a une croix.

Jeu normal Jeu truqué

Analyse du programme

1) Si on choisit un nombre entier au hasard entre 0 et 9, combien y-a-t-il d’issues pos-

sibles ?
2) Si pour gagner il faut obtenir un nombre entre 0 et 4, combien y-a-t-il d’issues favo-
rables ?
3) Calculer la probabilité de gagner avec la version normale du programme. Donner
le résultat sous forme de fraction, de nombre décimal et de pourcentage.
4) Avec le même raisonnement, calculer la probabilité de gagner avec la version tru-
quée du programme. Donner le résultat sous forme de fraction, de nombre décimal
et de pourcentage.

51
Activité

Analyse du programme

5) Jouer des parties par séquence de 25 parties et noter G pour gagner et P pour
perdu, dans votre cahier.
6) En utilisant vos résultats, compléter le tableau ci-dessous. Attention ! Bien prendre son
temps pour compter.

7) Compléter le graphique correspondant à la dernière ligne du tableau : placer un

point par colonne, relier les points par des segments et légender les axes.
Donner un titre au graphique.

8) Analyser le graphique et conclure sur le programme qui est téléchargé dans votre
carte.
Argumenter avec une ou plusieurs phrases.

Notes pour l’enseignant

R EMARQUE
Le code interactif est accessible en ligne :
Jeu normal [Link]
Jeu truqué [Link]

52
 Pile ou face avec Micro:bit

D ESCRIPTION
Objectif

Le but de ce projet est de simuler une expérience aléatoire de lancer de pièce avec une
carte Micro:bit.
À partir d’une situation simple, idéale pour une prise en main de l’interface de program-
mation, il s’agit par la suite d’améliorer le programme pas à pas. L’objectif est d’obtenir
un programme utilisable dans le cadre d’un cours sur les statistiques et les probabilités.

Intérêt
Bien évidemment, travailler avec une carte Micro:bit n’exclut pas de réaliser des expériences aléa-
toires réelles (pièces, dés, etc.). Cependant, il est très intéressant pour l’enseignant d’utiliser des
Micro:bit dans cette partie du programme.

Simplicité de la situation. La situation est très simple à expliquer et les élèves comprennent le but à
atteindre. L’absence de difficulté mathématique rend cette situation particulièrement simple à
mettre en œuvre.
Motivation des élèves. L’envie de programmer un objet connecté est grande pour les élèves. Cette
façon de programmer, utile, concrète et appliquée, leur correspond parfaitement.
De nombreuses solutions/améliorations possibles. Comme pour bien des projets, il y a plusieurs
façons d’arriver à la solution. Par ailleurs, les élèves peuvent apporter ou proposer de nom-
breuses améliorations. La programmation par bloc, exempte de difficulté syntaxique, est parti-
culièrement adaptée à la créativité.
Travail mathématique sur la modélisation. Cette compétence n’est pas facile à mettre en œuvre.
Ici, l’absence de difficulté mathématique rend ce travail beaucoup plus accessible à tous.

Matériel

— 1× Micro:bit (facultatif car le simulateur peut suffire)

— 1 × accès internet : IDE programmation par bloc [Link]

53
Niveau simple

N IVEAU SIMPLE
Activité élève

Durée Public Maths Sciences Algo

affichage ;
expérience
0,5 h 2de boucle ;
aléatoire
événement.

ACTIVITÉ
Mission : Utilise Micro:bit pour jouer à Pile ou Face !
En t’aidant des blocs ci-dessous, programme Micro:bit pour :
1) afficher une courte animation ;
2) afficher de façon aléatoire 0 ou 1.

54
Niveau simple
Notes pour l’enseignant
Ce premier niveau permet de se familiariser avec l’interface tout en produisant un premier pro-
gramme fonctionnel et utile.
Le programme à assembler est disponible en suivant ce lien :

[Link]

M ÉTHODE R EMARQUE
Pour résoudre ce problème, il suffit de pro- Plus d’informations sur la page de l’activité :
grammer les instructions de la façon sui- [Link]
vante : latest/decouverte/[Link]

55
Niveau intermédiaire

N IVEAU INTERMÉDIAIRE
Activité élève

Durée Public Maths Sciences Algo

affichage ;
boucle ;
expérience
0,5 h 2de événement ;
aléatoire
condition ;
fonction.

ACTIVITÉ
Maintenant, améliore le programme de ton Micro:bit.
Voici deux idées :
— au lieu d’afficher 0 ou 1, affiche plutôt P ou F ;
— utilise une fonction pour gérer ton animation.

56
Niveau intermédiaire
Notes pour l’enseignant
Ce deuxième niveau est l’occasion d’introduire les notions de fonctions et les instructions condition-
nels.

Le programme à assembler est disponible en suivant ce lien :

[Link]

M ÉTHODE
Voici une proposition qui fonctionne :

R EMARQUE
Plus d’informations sur la page de l’activité :
[Link]

57
Niveau expert

N IVEAU EXPER T
Activité élève

Durée Public Maths Sciences Algo

affichage ;
boucle ;
événement ;
condition ;
expérience
0,5 h 2de fonction ;
aléatoire
variable
(incément) ;
texte (conca-
ténation).

ACTIVITÉ
Est ce que Micro:bit peut afficher les tirages obtenus ?
Pour finir, nous souhaitons ajouter une fonctionnalité supplémentaire
à Micro:bit. Il faut maintenant arriver à afficher l’effectif total pour les Piles et pour les
Faces.
Regarde ci-dessous les instructions que tu pourrais ajouter.

58
Niveau expert
Notes pour l’enseignant
Dans ce troisième niveau, nous souhaitons compter les issues obtenues et afficher les totaux. Il faut
introduire la notion de variable informatique.

Le programme à assembler est disponible en suivant ce lien :

[Link]

M ÉTHODE
Le résultat escompté est le suivant :

R EMARQUE
Plus d’informations sur la page de l’activité :
[Link]

59
 Fluctuation d’échantillonnage avec
Micro:bit

D ESCRIPTION
Objectif
Le but de ce projet est d’expérimenter la fluctuation d’échantillonnage à partir d’une
situation classique, en établissant tout d’abord un modèle d’expérience aléatoire à partir
des données de la situation, puis en proposant de programmer le tirage d’échantillons
pour une taille n fixée.

Intérêt
L’utilisation de l’interface Micro:bit permet d’obtenir rapidement un programme fonctionnel, mais
aussi d’afficher graphiquement la série de données produites. Cela représente un intérêt non-négligeable
lorsque l’on souhaite traiter la fluctuation d’échantillonnage.

Simulation d’une grande série d’expériences aléatoires Contrairement à l’usage du tableur, où

l’élève va devoir manipuler un grand nombre de données en colonnes et en lignes, au risque
de se perdre dans leur traitement, l’approche algorithmique de ce problème permet d’aller à
l’essentiel.
Afficher les données En utilisant le navigateur chrome, il est possible de recueillir les données géné-
rées et de les visualiser. L’échellle du graphique se réglant automatiquement sur le maximum
et le minimum des données, cela permet une compréhension immédiate du phénomène.

Matériel

— 1× Micro:bit (facultatif car le simulateur peut suffire)

— 1 × accès internet : IDE programmation par bloc [Link]
— lien vers l’activité 1 : [Link]
— lien vers l’activité 2 : [Link]
— lien vers l’activité 3 : [Link]

60
Description
Progression proposée

M ÉTHODE
On propose ici d’aborder la problématique en trois temps :

1) Prise en main - Vérifier le modèle.

Pour faciliter la prise en main et gagner du temps on propose aux élèves de vérifier
un code déjà prêt. Cela facilite l’appropriation du problème.
2) Intermédiaire - Du modèle à la génération d’échantillons.
À partir du modèle, l’élève doit élaborer un algorithme afin de produire des échan-
tillons de taille fixé.
3) Avancé - Visualisation des données
Cette étape consiste en une amélioration du programme précédent afin de pouvoir
visualiser les données issues de la simulation.

61
Niveau prise en main - Vérifier le modèle...

N IVEAU PRISE EN MAIN - V ÉRIFIER LE MODÈLE . . .

Activité élève

Durée Public Maths Sciences Algo

statistiques et instruction
0,3 h première
probabilités conditionnelle

ACTIVITÉ
Ta Mission : Utiliser Micro:bit pour simuler des naissances!
La situation est la suivante : à Ufa, en Russie, 51,2 % des naissances
sont des garçons.
Dans cette ville, une usine agrochimique expose ses employés à des
pesticides contenant de la dioxine.
D’après une étude de l’université de Montréal, parmi les 227 enfants nés d’un parent tra-
vaillant dans cette usine, 91 sont des garçons.
Cette étude cherche à déterminer si l’usine interfère sur les naissances.
Pour simuler les naissances à Ufa, on propose d’utiliser le programme ci-dessous.
Expliquer pourquoi ce programme modélise correctement les naissance à Ufa.
Proposer une façon de l’exploiter afin de vérifier l’influence des produits chimiques sur les
naissances.

Notes pour l’enseignant

M ÉTHODE
Dans cette activité, il s’agit de vérifier que les élèves ont bien compris la problématique
et notamment comment est utilisé la fréquence d’apparition du caractère "garçon".
Bien entendu il faut suggérer aux élèves de tester le programme, afin d’en appréhender

62
Niveau prise en main - Vérifier le modèle...

les limites.

R EMARQUE
Ici l’utilisation de la variable p n’est pas indispensable pour l’algorithme. Son intérêt est
pédagogique : elle permet de mettre en évidence la donnée utilisée ainsi que de de
faire le lien avec le vocabulaire et les notations utilisées dans le cours.
Avant de passer à l’activité 2, il peut être préférable de lister avec les élèves les éléments
manquants qui permettraient de produire et de traiter un échantillon comparable à celui
de l’étude :
— une boucle répéter afin de produire un échantillon de taille 227
— des variables pour dénombrer les naissances de garçons (et de filles ?)

63
Niveau intermédiaire - Générer des échantillons...

N IVEAU INTERMÉDIAIRE - G ÉNÉRER DES ÉCHANTILLONS . . .

Activité élève

Durée Public Maths Sciences Algo

instruction
statistiques et
0,5 h première condition-
probabilités
nelle ; boucle

ACTIVITÉ
Ta Mission : Utiliser Micro:bit pour simuler des naissances!
Utilise les blocs proposés afin de générer des échantillons de taille
identique à celui de l’étude.
Construire un programme qui affiche le nombre de garçons obtenus
dans un échantillons de 227 naissances.
Utiliser le programme afin de vérifier si la situation de la problématique est vraisemblable.

64
Niveau intermédiaire - Générer des échantillons...
Notes pour l’enseignant

M ÉTHODE
Dans cette activité, il s’agit de vérifier que les élèves se sont bien appropriés la probléma-
tique, notamment par rapport à la taille de l’échantillon.
Bien entendu il faut suggérer aux élèves de tester le programme plusieurs fois.
Le programme attendu peut être celui-ci si l’élève a utilisé tous les blocs proposés (voir
Remarque ci-dessous) :

R EMARQUE
Ici l’utilisation de la variable f n’est pas indispensable pour l’algorithme. Son intérêt est pé-
dagogique : elle permet de faire le lien avec l’activité précédente en conservant le mo-
dèle proposé.
Avant de passer à l’activité 3, il est tout de même préférable de faire s’interroger les
élèves sur la nécessité de l’existence de la variable f.
Enfin, on interrogera les élèves sur le nombre d’échantillons qu’ils jugent nécessaires afin
de valider leurs hypothèses.

65
Niveau avancée - Produire des données...

N IVEAU AVANCÉE - P RODUIRE DES DONNÉES . . .

Activité élève

Durée Public Maths Sciences Algo

boucles
statistiques et imbriquées ;
0,5 h première
probabilités communica-
tion

ACTIVITÉ
Ta Mission : Utiliser Micro:bit pour simuler des naissances et
produire des données!
Utilise les blocs proposés afin de générer 100 échantillons de taille
identique à celui de l’étude.
Construire un programme qui envoie une série de 100 valeurs, cha-
cune correspondant au nombre de garçon dans un échantillon.
Utiliser le programme et la fonctionnalité Afficher la console du simulateur pour visualiser
les données.
Exploiter les données produites pour déterminer si l’usine interfère sur les naissances de
garçons.

66
Niveau avancée - Produire des données...
Notes pour l’enseignant

M ÉTHODE
Dans cette activité, il s’agit de vérifier que les élèves sont bien capable d’interpréter le
graphique obtenu.
Bien entendu il faut suggérer aux élèves de tester le programme plusieurs fois, en prenant
soin d’attendre la fin d’une série avant d’en lancer une deuxième
Le programme attendu peut être celui-ci :

R EMARQUE
On interrogera les élèves sur les minimum et les maximum observés et sur la fréquence
d’apparition d’un effectif inférieur ou égal à 91.
Les données produites sont exportables en .csv et donc exploitables dans un tableur.

67
 Chutes et oscillations avec Micro:bit

D ESCRIPTION
Objectif
Le but de ce projet est de programmer un Micro:bit pour récupérer le nombre de chutes
subies afin d’étudier les mouvement oscillants verticaux.
En partant d’une situation simple (compter des chutes), le programme va être étoffé
afin de pouvoir déterminer la période des oscillations. Il faudra tout de même paramé-
trer avec soin le système oscillant et vérifier que la fonction du Micro:bit qui permet de
détecter une chute libre se déclenche effectivement lors des mouvement du système. Il
s’agit notamment de veiller à ce que l’amplitude soit suffisante.

Intérêt
Cette activité permet d’effectuer des mesures physiques de façon simple et efficace tout en de-
mandant un minimum de programmation.
Simplicité de la situation. La situation est très simple à expliquer et les élèves comprennent le but
à atteindre. La problématique liée à l’affichage dans le niveau 1 permet d’aborder des pro-
blèmes de tris classiques en programmation, c’est l’occasion de voir comment des notions
simples de mathématiques (arrondi, modulo) sont utiles dans ce type de situation.
Motivation des élèves. Dans cette activité, l’élève est acteur tout au long de la chaîne de l’expé-
rimentation et utilise un composant électronique que l’on retrouve dans de nombreux objets
(téléphone, manettes de jeux, hoverboard...).
De nombreuses solutions/améliorations possibles. Cette activité propose une solution qui est suf-
fisante pour étudier les oscillations, puisqu’elle ne fait qu’automatiser un traitement qui pou-
vait être fait à la main. Néanmoins il est envisageable par exemple de coupler un deuxième
Micro:bit afin de recueillir et de traiter les données en directes.
Démarche scientifique. Il peut être intéressant de faire évaluer la précision du Micro:bit afin de
vérifier que la fiabilité des mesures. Par exemple une même expérience pourrait faire l’objet
d’une mesure avec le Micro:bit, avec un opérateur manuel et à l’aide de la vidéo. La dé-
tection de la chute libre a été évoquée précédemment, là encore il est intéressant d’étudier
avec les élèves les limites de l’expérience.

Matériel

— 1× Micro:bit
— 1 × accès internet : IDE programmation par bloc [Link]
— ressorts de différentes raideurs
— 1 support vertical
— masses marquées

68
Niveau simple

N IVEAU SIMPLE
Activité élève

Durée Public Maths Sciences Algo

affichage ;
1h terminale repérage mécanique événement ;
tri ; variable

ACTIVITÉ
Utilise Micro:bit pour compter et afficher un nombre de chutes !
En t’aidant des blocs ci-dessous, programme Micro:bit pour :
1) programmer un événement lorsque l’appareil est en chute libre ;
2) itérer une variable correspondant au nombre de chutes subies
par le Micro:bit.
3) afficher ce nombre en allumant une nouvelle LED à chaque
chute.

69
Niveau simple
Notes pour l’enseignant
La difficulté de ce niveau tient dans l’affichage, ce qui pourrait facilement être contournée en af-
fichant simplement un nombre plutôt qu’en allumant une nouvelle LED à chaque nouvelle chute.
Néanmoins il est intéressant d’étudier comment ce problème d’affichage peut-être résolu simple-
ment avec les deux opérateurs mathématiques arrondi et modulo.

M ÉTHODE R EMARQUE
Pour résoudre ce problème, il suffit de programmer les La page vers l’interace de pro-
instructions de la façon suivante : grammation avec le code prêt à
télécharger :
[Link]
xxxxxxxxx

70
Niveau intermédiaire

N IVEAU INTERMÉDIAIRE
Activité élève

Durée Public Maths Sciences Algo

affichage ;
indicateurs
1h Term mécanique événement ;
statistiques
variable ; liste

ACTIVITÉ
Utilise Micro:bit pour déterminer une période moyenne une période
moyenne d’oscillation !
En t’aidant des blocs ci-dessous, programme Micro:bit pour :
1) programmer un événement lorsque l’appareil est en chute libre ;
2) itérer une variable correspondant au nombre de chutes subies par le Micro:bit.
3) utiliser le bloc temps d’exécution pour mesurer la durée d’un nombre d’oscillation
déterminé (10 par exemple)
4) calculer la période moyenne d’oscillation (en ms et afficher le résultat
Attention tous les blocs ne sont pas représentés : certains doivent être doublés et/ou mo-
difiés.

71
Niveau intermédiaire
Notes pour l’enseignant

M ÉTHODE
Pour résoudre ce problème, il suffit de programmer les instructions de la façon suivante :

72
Mémo Mu-Editor pour Micro:bit (et python)
M ÉTHODE (1 ER PROGRAMME )

Afficher un premier texte sur l’écran Micro:bit. Ouvrir Mu-editor

Connecter la carte à l’ordinateur Copier le code ci-dessous.

from microbit import *

[Link]("Hello, World!")

Flasher la carte (envoyer le programme dans la carte)

M ÉTHODE (D ES IMAGES ) M ÉTHODE (L ES MOUVEMENTS )

Afficher une image sur l’écran du Micro:bit. Afficher des enregistrements de l’accéléromètre

Copier le code et flasher la carte Copier le code et flasher la carte

from microbit import * from microbit import *

for loop in range (10): [Link]([Link])
[Link]([Link]) while True:
sleep(100) valeurs= accelerometer.get_values()
[Link](Image.HEART_SMALL) print (valeurs)
sleep(50) sleep(100)
[Link]("Hello, World!")
Afficher la vue REPL (terminal série)

Réinitialiser le Micro:bit

R EMARQUE
Vous devriez avoir un affichage du type
 M ÉTHODE (G RAPHIQUE ) R EMARQUE
Afficher les enregistrements de l’accéléromètre Vous devriez avoir un affichage du type
sous forme de graphique

Copier le code et flasher la carte

from microbit import *

[Link]([Link])
while True:
valeurs= accelerometer.get_values()
print (valeurs)
sleep(100)

Afficher la vue Graphique

Réinitialiser le Micro:bit

M ÉTHODE (C OMMUNICATION RADIO ) M ÉTHODE (E NREGISTRER DES FICHIERS )

 Mémo Micro:bit (et python)
M ÉTHODE (E SSENTIEL )
Importer toutes les fonctions from microbit import *
Faire une pause (en ms) sleep(...)

M ÉTHODE (É CRIRE DANS UN TERMINAL ) R EMARQUE

Écrire du texte (string) print() Activer la communication série
ex. P print('Bouton A : 5 fois')
Aligner avec des tabulations '\t'
ex. P
print('Bouton \tA\t:\t5 fois')
Sauter des lignes '\n'
ex. P print('Bouton A :\n5 fois\n')
Convertir en chaînes (string) str()
ex. P
print('Bouton A :' + str(5) +' fois')

M ÉTHODE (LED Micro:bit)

Afficher texte/image [Link]()
ex. P [Link]("G")
ex. P [Link]([Link])
Faire défiler texte/image [Link]()
ex. P [Link]("Gagne !") R EMARQUE
ex. P [Link]([Link]) Pour créer/utiliser des animations,
Créer des animations delay=...
P
=⇒ tableaux d’images.
ex. [Link](Image.ALL_CLOCKS, delay=200) ex. P Image.ALL_CLOCKS (lignes)
Modifier pixel display.set_pixel(x,y,lum) ex. P Image.ALL_ARROWS (flèches)
(lum = luminosité [0 ;9]) ex. P display.set_pixel(0,4,9)
Effacer l’écran [Link]()

[Link] Image.CLOCK12 [Link] [Link]

Image.HEART_SMALL Image.CLOCK11 [Link] [Link]
[Link] ... Image.DIAMOND_SMALL [Link]
[Link] Image.CLOCK1 [Link] [Link]
[Link] Image.ARROW_N Image.SQUARE_SMALL [Link]
[Link] Image.ARROW_NE [Link] [Link]
[Link] Image.ARROW_E [Link] [Link]
[Link] Image.ARROW_SE Image.MUSIC_CROTCHET [Link]
[Link] Image.ARROW_S Image.MUSIC_QUAVER [Link]
[Link] Image.ARROW_SW Image.MUSIC_QUAVERS [Link]
[Link] Image.ARROW_W [Link] [Link]
[Link] Image.ARROW_NW [Link] [Link]
[Link] [Link] [Link] [Link]
[Link] Image.TRIANGLE_LEFT [Link]
 M ÉTHODE (L ES BOUTONS )

Accéder aux boutons A ou B button_a. ...

button_b. ...
Nombre d’appuis (cumul) button_a.get_presses()
button_b.get_presses()
ex. P [Link](str(button_a.get_presses()))
Tester si bouton est pressé button_a.is_pressed()
button_b.is_pressed()
ex. P if (button_b.is_pressed()):print("Bouton B")
Tester si bouton a été pressé button_a.was_pressed()
(appeler 2 × la fonction) button_b.was_pressed()
ex. P if (button_b.was_pressed()):[Link]([Link])
Utiliser les broches pin0.is_touched()
pin1.is_touched()
pin2.is_touched()

R EMARQUE

Détecter un évènement, avec une boucle infinie. ex. P while True:

Pour sortir d’une boucle lorsque l’évènement est détecté : ex. P break

M ÉTHODE (A LÉA )
Activer le module hasard import random
Nombre aléatoire sur [0 ; 1] [Link]()
ex. P [Link](round([Link](),3))
Nombre entier aléatoire sur [a ; b] [Link](a,b)
ex. P [Link]([Link](1,6))

M ÉTHODE (M OUVEMENT )
1 coord. vect. accélération accelerometer.get_x()
accelerometer.get_y()
accelerometer.get_z() Gestes reconnus
ex. P [Link](accelerometer.get_x()) ’up’ ’freefall’
3 coord. vect. (tuple) accelerometer.get_values() ’down’ ’3g’
ex. P print(accelerometer.get_values()) ’left’ ’6g’
Historique gestes (tuple) accelerometer.get_gestures() ’right’ ’8g’
(appeler 2 × la fonction) ex. P print(accelerometer.get_gestures()) ’face up’
’face down’
’shake’
Tester geste actuel accelerometer.is_gesture('...')
Tester geste passé accelerometer.was_gesture('...')
(appeler 2 × la fonction)
 M ÉTHODE (R ADIO )
Activer le module radio import radio
Mettre en route la radio [Link]()
Envoyer un message [Link]('...')
ex. P [Link]('pile')
Message reçu (string) (= None si vide) [Link]()
ex. P
if ([Link]()=='pile'): print('Pile')
[Link](channel=..)


Canal perso (⩽ 100
ex. P [Link](channel=21)
[Link](power=..)


Puissance perso (⩽ 7
ex. P [Link](power=7)

M ÉTHODE (B OUSSOLE )
1 coord. vect. champ magnétique compass.get_x()
compass.get_y()
compass.get_z()
ex. P [Link](compass.get_x()) R EMARQUE
Angle (en ◦ ) avec le nord [Link]()
ex.P aiguille=(([Link]())//30)%12
Toujours calibrer la boussole.

Calibrer la boussole [Link]() Mesures/valeurs fluctuantes

(présence de métal, d’aimants, etc.)
 Simuler un dé avec Micro:bit (et
python)

D ESCRIPTION
Objectif
Le but de ce projet est de simuler une expérience aléatoire de lancer d’un dé à 6 faces
mais en nous appuyant sur les possibilités offertes par le langage Python.
Ainsi, on ne se contentera pas seulement d’afficher l’issue, mais on montrera comment
stocker et traiter facilement les effectifs obtenus.
Ici, contrairement à l’activité proposée en programmation par blocs, nous suggérons de
commencer par simuler l’affichage tel qu’il apparaît sur un vrai dé. Cela permet de réex-
ploiter les listes d’images introduites avec le projet pile ou face.
Cette activité permettra de couvrir de nombreuses capacités du programme de mathé-
matiques de seconde Bac Pro, tant dans le domaine des statistiques que celui de l’algo-
rithmique.

Intérêt
expérimenter En partant d’une modélisation simple, l’élève va pouvoir observer une expérience
aléatoire, dont il va facilement pouvoir visualiser et traiter les résultats.
programmation événementielle Pour déclencher les tirages et l’affichage, on peut utilise les bou-
tons, mais on peut imaginer utiliser la détection de mouvements.
gestion des listes Même les listes ne font pas partie explicitement des types de données que les
élèves sont sensés maîtrisées, il est difficile de s’en passer en programmation. Cependant, il ne
semble pas insurmontable de les initier aux principes de création, modification et parcours de
listes dans la mesure où l’on retrouve les notions de variables et de boucle for. La majeure diffi-
culté pourrait éventuellement provenir des index.
programmation fonctionnelle le calcul des fréquences peut se faire au travers d’une fonction, ce
qui permet de scinder la production des données et leur traitement.
de multiples déclinaisons possibles Une fois la situation du tirage d’un dé bien établie, il est facile-
ment envisageable d’étendre à d’autres situations : dés non conventionnels, dés multiples.

Matériel

— 1× Micro:bit
— 1 × IDE programmation python (Mu) [Link] ou interface de programmation
ligne [Link]

Remarques

M ÉTHODE
Pour afficher aléatoirement un nombre entier entre 1 et 6, on peut se contenter des 3
lignes ci-dessous.

78
Description

while True:
if button_a.get_presses():
[Link](str(randint(1, 6)))
sleep(800)

Cette solution peut être envisagée afin de simplifier l’approche, mais la création d’image
permet de travailler le repérage et la représentation des nombres, en plus de proposer un
affichage plus attrayant.

1) Initiation - Mise en place du modèle.

Dans cette activité, il s’agit de proposer aux élèves de créer les images et d’associer
l’affichage au résultat d’un tirage aléatoire.
2) Intermédiaire - Enregistrement des résultats.
L’étape suivante consistera d’une part à stocker les effectifs des différentes issues
dans une listes, et d’autre part à afficher les données recueillies.
3) Intermédiaire - Calcul des fréquences
Le dernier niveau consistera à déterminer les fréquences des issues. Pour cela on uti-
lisera une fonction pour calculer et arrondir.

79
Niveau initiation

N IVEAU INITIATION
Activité élève

Durée Public Maths Sciences Algo

affichage
0,5 h 2de probabilités
boucles listes

ACTIVITÉ
Ta Mission : Utiliser une carte Micro:bit pour simuler un dé, en
utilisant le langage Python.
Nous utiliserons la bibliothèque random et la fonction randint()
pour tirer un nombre entier aléatoirement entre deux bornes. Il faut donc importer un mo-
dule en plus de microbit :

from microbit import *

from random import randint

Le programme précédent devra être complété avec les éléments suivants :

1) Dans un premier temps nous allons créer les images nécessaires pour afficher les
nombres comme sur un vrai dé.
Par exemple le code ci-dessous permet de créer l’image représentant l’issue "cinq".

cinq = Image("90009:00000:00900:00000:90009")
Chaque nombre correspond à une diode, éclairée de 0 à 9.
2) Ces images sont ensuite enregistrée dans une liste :

issues = [un, deux, trois, quatre, cinq, six]

3) Après le démarrage de la boucle While True: on déclenchera le tirage avec le

bouton A : button_a.get_presses() .
4) La première image du tableau issues est numérotée à 0 et la dernière à 5. On
effectue donc un tirage aléatoire d’un entier entre 0 et 5, puis on demande au
Micro:bit d’afficher l’image correspondant à ce numéro.

i = randint(0, 5)
[Link](issues[i])

Vérifie ton code avec et flash-le sur la carte avec

80
Niveau initiation
Notes pour l’enseignant

M ÉTHODE
Proposition de résolution : Il faut bien entendu importer les modules nécessaires

from microbit import *

from random import randint

puis créer les images

un = Image("00000:00000:00900:00000:00000")
deux = Image("00009:00000:00000:00000:90000")
trois = Image("90000:00000:00900:00000:00009")
quatre = Image("90009:00000:00000:00000:90009")
cinq = Image("90009:00000:00900:00000:90009")
six = Image("90009:00000:90009:00000:90009")

et enfin créer la boucle permettant d’afficher le résultat d’un tirage :

if button_a.get_presses():
[Link](str(randint(1, 6)))
sleep(800)
[Link]()

R EMARQUE
Les deux dernières lignes ne sont pas indispensables, mais elles permettent de mieux diffé-
rencier les tirages, surtout lorsque l’on tire le même nombre.

81
Niveau intermédiaire

N IVEAU INTERMÉDIAIRE
Activité élève

Durée Public Maths Sciences Algo

affichage
0,5 h 2de probabilités
boucles listes

ACTIVITÉ
Ta Mission : Utiliser une carte Micro:bit pour simuler un dé, et
dénombrer les issues en utilisant le langage Python.
Comme pour l’activité précédente, nous utiliserons la bibliothèque
random et la fonction randint() , le programme commencera donc aussi par :

from microbit import *

from random import randint

Le programme de l’activité précédente devra être complété avec les éléments suivants,
à vous de déterminer quelle doit être leur position dans le programme :

1) Nous allons devoir stocker les effectifs des différentes issues, pour cela il faudra créer
un tableau de données que nous initialiserons avec des "0". Par exemple :
data = [0, 0, 0, 0, 0, 0]
2) Lorsqu’un nombre est tiré, il faudra augmenter l’effectif correspondant de 1. Étant
donné que l’on se sert déjà du nombre tiré aléatoirement pour afficher l’image, il
n’y a qu’une ligne à rajouter. Par exemple si le tableau s’appelle "data" :
data[i] = [data[i]+1
3) Pour déclencher l’affichage des effectifs, on utilisera le bouton B :
button_b.get_presses()
4) Pour parcourir le tableau, il faudra faire une boucle for ... in ... sur le tableau
et afficher chaque élément du tableau avec [Link](...) .

for effectif in data :

[Link](str(effectif)+" /")

82
Niveau intermédiaire
Notes pour l’enseignant

M ÉTHODE
Proposition de résolution :
Le début du programme est inchangé.

from microbit import *

from random import randint

un = Image("00000:00000:00900:00000:00000")
deux = Image("00009:00000:00000:00000:90000")
trois = Image("90000:00000:00900:00000:00009")
quatre = Image("90009:00000:00000:00000:90009")
cinq = Image("90009:00000:00900:00000:90009")
six = Image("90009:00000:90009:00000:90009")

issues = [un, deux, trois, quatre, cinq, six]

Il faut ajouter l’initialisation du tableau d’effectifs :

data = [0, 0, 0, 0, 0, 0]

Dans la boucle permettant d’afficher le résultat d’un tirage, il faut inclure l’incrémenta-
tion :

while True:
if button_a.get_presses():
i = randint(0, 5)
[Link](issues[i])
data[i] = data[i] + 1
sleep(1000)
[Link]()

L’affichage des effectifs se fait par parcours du tableau et défilement :

if button_b.get_presses():
for effectif in data :
[Link](str(effectif)+" /")

R EMARQUE
Cette activité étant très guidée, la complexité réside dans le positionnement des instruc-
tions proposées dans le programme et dans la compréhension du fonctionnement des
listes.
Les listes n’étant pas spécifiquement demandées dans le référentiel de seconde, elles
sont à utiliser avec précaution, il est aussi envisageable de créer des variables pour enre-
gistrer l’effectif de chaque issue, mais cela alourdi considérablement le programme.

83
Niveau avancé

N IVEAU AVANCÉ
Activité élève

Durée Public Maths Sciences Algo

affichage
0,5 h 2de probabilités boucles listes
fonctions

ACTIVITÉ
Ta Mission : Utiliser une carte Micro:bit pour simuler un dé,
et observer la fluctuaion des fréquences en utilisant le langage
Python.
Comme pour l’activité précédente, nous utiliserons la bibliothèque random et la fonc-
tion randint() , le programme commencera donc aussi par :

from microbit import *

from random import randint

Le programme de l’activité précédente devra être complété avec les éléments suivants,
à vous de déterminer quelle doit être leur position dans le programme :

1) Nous allons ajouter une fonction qui nous permettra de calculer les fréquences de
chaque issue.
2) Pour calculer les fréquences, il nous faut connaître l’effectif total des tirages, et donc
pour cela nous devons créer une variable N.
3) Afin d’obtenir rapidement un grand nombre de tirage, nous allons inclure les instruc-
tions liés au tirage dans une boucle de 10 répétitions.
4) Pour déclencher l’affichage des fréquences, on utilisera le bouton B :
button_b.get_presses()
5)

84
Niveau avancé
Notes pour l’enseignant

M ÉTHODE
Proposition de résolution :
Le début du programme est inchangé.

from microbit import *

from random import randint

un = Image("00000:00000:00900:00000:00000")
deux = Image("00009:00000:00000:00000:90000")
trois = Image("90000:00000:00900:00000:00009")
quatre = Image("90009:00000:00000:00000:90009")
cinq = Image("90009:00000:00900:00000:90009")
six = Image("90009:00000:90009:00000:90009")

issues = [un, deux, trois, quatre, cinq, six]

Il faut ajouter l’initialisation du tableau d’effectifs :

data = [0, 0, 0, 0, 0, 0]

Dans la boucle permettant d’afficher le résultat d’un tirage, il faut inclure l’incrémenta-
tion :

while True:
if button_a.get_presses():
i = randint(0, 5)
[Link](issues[i])
data[i] = data[i] + 1
sleep(1000)
[Link]()

L’affichage des effectifs se fait par parcours du tableau et défilement :

if button_b.get_presses():
for effectif in data :
[Link](str(effectif)+" /")

R EMARQUE
Cette activité étant très guidée, la complexité réside dans le positionnement des instruc-
tions proposées dans le programme et dans la compréhension du fonctionnement des
listes.
Les listes n’étant pas spécifiquement demandées dans le référentiel de seconde, elles
sont à utiliser avec précaution, il est aussi envisageable de créer des variables pour enre-
gistrer l’effectif de chaque issue, mais cela alourdi considérablement le programme.

85
 Pile ou face communicant avec
Micro:bit (et python)

D ESCRIPTION
Objectif
Le but de ce projet est de simuler une expérience aléatoire de lancer de pièce truquée
avec une carte Micro:bit. et d’envoyer par radio l’issue afin de centraliser les résultats.
Cette activité permet de prendre en main facilement l’interface de développement en
python

Intérêt
Cette activité, idéale pour découvrir l’interface de programmation, propose d’utiliser python pour
programmer une situation non-équiprobable et d’exploiter le module radio du Micro:bit.
Production et traitement de données Cette situation permet de travailler des notions de probabili-
tés et de statistiques.
Programmation Python Cette activité nécessite que les élèves aient déjà été initié à Python, sans
pour autant demandé une grande maîtrise.

Matériel

— 1× Micro:bit
— 1 × IDE programmation python (Mu) [Link] ou interface de programmation
ligne [Link]

Progression proposée

M ÉTHODE
On propose ici d’aborder la problématique en deux temps :

1) Tirage aléatoire et envoi des issues

Les élèves doivent modéliser une expérience aléatoire avec une probabilité don-
née, et envoyer l’issue par radio.
2) Réception et traitement des données
L’incrémentation des variables et le traitement des données est déclenchée par la
réception d’un message radio.

86
Niveau simple

N IVEAU SIMPLE
Activité élève

Durée Public Maths Sciences Algo

fonction ;
expérience
0,5 h 2de événement ;
aléatoire
boucle

ACTIVITÉ
Mission : Programme Micro:bit pour simuler un lancer de Pile ou Face truqué !
On veut que notre pièce virtuelle ait 55% de chance de tomber sur "pile".
Le programme doit débuter avec les instructions ci-dessous afin :
1) d’ importer les bibliothèques nécessaires ;

from microbit import *

import random
import radio

2) allumer le mode radio ; [Link]()

3) lancer une boucle infinie et détecter si le Micro:bit a été secoué ;

while True:
if accelerometer.was_gesture('shake'):

Il faut maintenant ajouter les fonctions pour :

1) effectuer un tirage aléatoire d’un nombre entre 1 et 100 avec [Link](,)
et comparer ce nombre à la probabilité voulue.
2) afficher P ou F selon l’issue du tirage avec [Link]('') ;

3) envoyer la valeur ’P’ ou ’F’ par radio selon l’issue du tirage avec [Link]('')

Vérifie ton code avec et flash-le sur la carte avec

87
Niveau simple
Notes pour l’enseignant
Ce premier niveau permet de se familiariser avec l’interface de l’IDE en produisant un premier pro-
gramme fonctionnel et utile. Les notions de programmations utilisées sont :
1) l’appel de fonction
2) la boucle while
3) la boucle if
Dans cette première partie l’élève est aussi amené à concevoir une expérience aléatoire avec une
probabilité donnée.

M ÉTHODE
Pour résoudre ce problème, il suffit de programmer les instructions de la façon suivante :

from microbit import *

import random
import radio

[Link]()

while True:
if accelerometer.was_gesture('shake'):
tirage = [Link](1, 100)

if tirage <= 55:

[Link]("P")
[Link]('P')
else:
[Link]("F")
[Link]('F')
sleep(10)

R EMARQUE
La variable tirage n’est pas indispensable, elle permet d’enregistrer le résultat du ti-
rage aléatoire et de rendre le code plus lisible.
L’instruction sleep(10) permet de faire une pause de 10 ms dans le programme.
Afin de distinguer deux tirages successifs, on peut marquer une pause puis effacer l’écran
à l’issue d’un tirage avec [Link]() , mais il peut-être amusant de montrer com-
ment faire une animation simplement à partir d’une succession d’images.
Par exemple la fonction anim() ci-dessous pourra être définie au début du programme
puis appeler avant chaque tirage.

while True:
if accelerometer.was_gesture('shake'):
tirage = [Link](1, 100)
anim()

88
Niveau Expert

N IVEAU E XPER T
Activité élève

Durée Public Maths Sciences Algo

fonction ;
0,5 h 2de fréquences événement ;
variable

ACTIVITÉ
Mission : Réceptionne les données envoyées par les autres Micro:bit et
exploite-les pour tracer un graphique
Dans l’activité précédente nous avons créer une pièce virtuelle qui affiche ’P’ ou ’F’ et
qui envoie cette information par radio. Nous allons programmer le Micro:bit afin de rece-
voir, traiter et afficher les données.
Le programme précédent devra être complété avec les éléments suivants :
1) une déclaration de variables pour dénombrer les ’P’ et les ’F’, comme par exemple
p = 0 , qu’il faut écrire avant la boucle while True:
2) la réception d’un message radio (que l’on pourra enregistrer dans une variable ’is-
sue’) avec la fonction [Link]() ;
3) l’incrémentation des variables décomptant les ’P’ et les ’F’ par exemple p = p + 1
;
4) le calcul de fréquence de ’P’ et de ’F’ (attention il faudra veiller à ne pas diviser par
0) ;
5) l’affichage des fréquences dans le plotter avec print((a,b)) où ’(a,b)’ est le
couple de fréquences de ’P’ et de ’F’ dont on souhaite voir l’évolution au cours du
temps.

Vérifie ton code avec et flashe-le sur la carte avec .

Avant d’afficher le plotter avec , il faudra peut-être faire un reset de la carte.

89
Niveau Expert
Notes pour l’enseignant
Cette deuxième activité nécessite impérativement l’usage de variables.
La difficulté peut provenir des différents cas de figure à traiter, mais à part l’instruction else: , il n’y
a pas de nouveaux types d’instruction.
Les notions de programmations utilisées sont :
1) la déclaration et l’initialisation de variables
2) la boucle if , complété par else
Dans cette partie l’élève est aussi amené à calculer des fréquences, mais l’exécution de ce calcul
doit être conditionné à la non nullité de la somme des variables.

M ÉTHODE
Pour recevoir et exploiter les données, il est possible de programmer les instructions de la
façon suivante :

from microbit import *

import random
import radio

[Link]()

f = 0
p = 0

def anim():
tab = [Image.ARROW_N, Image.ARROW_NE, Image.ARROW_E, Image.ARROW_SE,
Image.ARROW_S, Image.ARROW_SW, Image.ARROW_W, Image.ARROW_NW]
[Link](tab, delay=80)

while True:
if accelerometer.was_gesture('shake'):
tirage = [Link](1, 100)
anim()
if tirage <= 55:
[Link]("P")
[Link]('P')
else:
[Link]("F")
[Link]('F')
sleep(10)

issue = [Link]()
if issue == 'P':
p += 1
if issue == 'F':
f += 1
if p+f > 0:
a = p/(p+f)
b = f/(p+f)
else:
a, b = 0, 0
print((a, b))
sleep(10)

90
 Robot Maqueen et capteur de distance

D ESCRIPTION
Objectif

Le but de cette séquence est d’utiliser et d’étalonner le capteur de distance ultrasonique

du robot Maqueen. Ce capteur sera utilisé en tant que télémètre.
Après un étalonnage utilisant un modèle linéaire, nous proposons de programmer le robot
afin qu’il s’arrête à une distance précise d’un obstacle.

Intérêt
Capteur piézoélectrique La mise en œuvre du détecteur permet d’utiliser un capteur piézoélec-
trique de façon concrète.
Propagation du son dans un milieu Une explication théorique du fonctionnement du capteur per-
met de parler de la célérité du son dans l’air et de la notion d’ultrason.
Régression linéaire L’étalonnage permet de mettre en application sur un cas concret la régression
linéaire.
Mouvement du robot La dernière partie permet de relier mouvement et détection, avec une auto-
matisation basique.

Matériel

— 1× Micro:bit

— 1× Maqueen (et son capteur intégré de distance ultrasonore)

— 1 × tableau magnétique
— 1 × règle graduée d’un mètre
— 1 × accès Internet :

• 1 × accès Internet : IDE programmation par bloc [Link]

• 1 × accès en ligne à l’extension pour la programmation par bloc du robot Maqueen :
[Link]

91
Description
Remarques
Le robot Maqueen est un robot pilotable à l’aide d’une carte
Micro:bit.
Ce dernier est équipé de 2 roues motorisées, d’un buzzer, de 2
leds rouges de signalements, de 4 leds Neopixel, de 2 capteurs de
lignes, d’un capteur de télécommande infrarouge et d’un capteur
de distance à ultrason. C’est ce dernier capteur que nous allons uti-
liser, ainsi que les moteurs.
Le détecteur envoie une pulsation sonore de fréquence 40kHz et
mesure le temps que met l’onde pour faire l’aller-retour après ré-
flexion sur un obstacle. Ce temps permet ainsi d’estimer une distance en reliant temps, célérité de
l’onde et distance par la relation : d = c×t
2 avec la distance d en m, la célérité c du son dans l’air en
m/s et t le temps en s.
Pour chaque robot, un étalonnage est obligatoire à chaque séance car :
— la célérité dépend de la température
— l’horloge interne des Micro:bit n’est pas très précises.

M ÉTHODE
Installation de la bibliothèque Maqueen pour Makecode

1) Dans l’éditeur Makecode de Viens Coder, cliquer sur le bouton « Extension ».

2) Dans l’interface de recherche, entrer l’adresse suivante : [Link]

DFRobot/pxt-maqueen

3) Cliquer sur Maqueen et une nouvelle famille de blocs apparait.

92
Description

4) Le bloc sensor unit permet de mesurer la distance, Motor à faire tourner les moteurs
(M1 gauche, M2 droit) et Motor stop à les arrêter.

93
Niveau initiation - Utilisation du capteur de distance à ultrasons

N IVEAU INITIATION - U TILISATION DU CAPTEUR DE DISTANCE À UL -

TRASONS
Activité élève

Durée Public Maths Sciences Algo

0,5 h 2de

ACTIVITÉ
Première programme avec le robot Maqueen.
Ta Mission : Sauras-tu utiliser le programme ci-dessous pour
programmer ton robot Maqueen?

Notes pour l’enseignant

M ÉTHODE
Proposition de résolution :
— Télécharger le programme puis le téléverser sur la carte Micro:bit.
— Insérer la carte dans le robot Maqueen.
— Tester le programme en mesurant la distance (bouton A) à divers objets et chercher
les limites du détecteur (angle de visée, objet non plat. . .)

R EMARQUE
Nous rappelons qu’il est indispensable d’installer l’extension Maqueen sur l’interface Make-
code ([Link]

94
Niveau intermédiaire - Étalonnage du capteur

N IVEAU INTERMÉDIAIRE - É TALONNAGE DU CAPTEUR

Activité élève

Durée Public Maths Sciences Algo

nuage de
2de, 1ère, points,
1,5 h
Term régression
linéaire

ACTIVITÉ
Le capteur du robot Maqueen est très précis, mais malheureusement
il donne souvent des valeurs faussées à cause de la chaleur et de la
carte Micro:bit.
Pour corriger cela, il est indispensable de l’étalonner.
Ta Mission : Nous avons besoin de toi pour étalonner le robot Maqueen de la
classe.
Si tu le désires, tu peux utiliser une règle, un obstacle (comme un tableau magnétique) et
t’inspirer des deux indices ci-dessous. . .

Notes pour l’enseignant

M ÉTHODE

Proposition de méthode de résolution :

1) Placer le robot à 10 cm, 15 cm,20 cm . . . 100 cm d’un tableau de mécanique faisant

obstacle.
2) Relever avec le capteur du robot les distances.

95
Niveau intermédiaire - Étalonnage du capteur

3) Renouveler l’opération pour chaque distance.

4) Dans un tableur, tracer la distance réelle en fonction de la distance mesurée par le
capteur.
5) Modéliser le nuage de points par une régression linéaire.
6) Avec les blocs Maths, corriger le programme original pour afficher désormais une
distance plus proche de la distance réelle prenant en compte la régression.

96
Niveau expert - Robot autonome

N IVEAU EXPER T - R OBOT AUTONOME

Activité élève

Durée Public Maths Sciences Algo

1h 1ère, Term

ACTIVITÉ
Ta Mission : Programme le robot Maqueen pour qu’il avance quand
on appuie sur le bouton A puis s’arrête à 20 cm d’un obstacle.

Notes pour l’enseignant

M ÉTHODE R EMARQUE
Proposition de résolution : Les élèves peuvent aussi programmer un ra-
dar de recul en utilisant aussi le haut-parleur
du robot Maqueen.

97
 Déterminer une vitesse avec MBot

D ESCRIPTION
Objectif
Le but de ce projet, liées au programme de Maths-Sciences en CAP ou Bac Pro, est d’uti-
liser le robot MBot pour travailler sur le mouvement et la mesure.
Outre la vitesse, qui est au centre du projet, une travail sur l’erreur, l’incertitude et les sta-
tistique est possible.

Intérêt
Détermination de mesures physiques Ces activités proposent d’étudier un questionnement essen-
tiel de physique : comment mesurer une vitesse ? Deux grandeurs sont donc à déterminer le
plus précisément possible : une distance et un temps.
Mouvement uniforme ou accéléré Le robot MBot met un certain temps à démarrer : le mouvement
est donc accéléré puis uniforme.
Travail sur l’incertitude Il est intéressant de déterminer la vitesse lorsque le mouvement est uniforme.
Ainsi il sera obligatoire de lancer le chrono après le départ. Ce qui est intéressant car cela en-
gendre un travail sur l’erreur et permet un calcul d’incertitude.
Étude statistique Un travail statistique pourra découler de ces mesures. Par exemple, il est intéres-
sant de déterminer de moyenne et écart type.

Matériel

— 1× MBot
— 1 × accès internet : IDE programmation par bloc [Link]

Remarques

M ÉTHODE
Dans la réalisation, nous suggérons d’utiliser un seul robot puis de demander aux élèves
de mesurer temps et distance (donner 1 chronomètre par groupe ou utiliser les télé-
phone).
Récupérer ensuite l’ensemble des résultats (une dizaine) puis proposer de les exploiter
afin de déterminer une valeur précise et acceptable de durée et distance. Il sera sans
doute nécessaire de refaire les expériences au besoin.
L’objectif n’est pas d’obtenir des valeurs identiques, mais d’analyser les conditions de l’ex-
périence et de mesures pour en améliorer la précision.

98
Niveau initiation - Programmer le déplacement de MBot

N IVEAU INITIATION - P ROGRAMMER LE DÉPLACEMENT DE MBot

Activité élève

Durée Public Maths Sciences Algo

instructions de
déplacement ;
1h 2de translation
temporisation ;
entrées clavier

ACTIVITÉ
Dans le cadre de la conduite autonome d’un véhicule le conducteur programme la vi-
tesse à laquelle il souhaite rouler.
Ta Mission : Programmer le déplacement du robot MBot en utilisant le
logiciel MBlock ?

ACTIVITÉ
Ta Mission : Stopper le déplacement du robot MBot si l’on presse la
touche « Espace » du clavier.

Notes pour l’enseignant

M ÉTHODE R EMARQUE
La plupart des élèves ne vont pas prévoir de Concernant la conduite autonome, il est
stopper le robot. possible de montrer la première minute de
cette vidéo.
Il est possible d’utiliser des vitesses différentes
que celles proposées ou encore des vitesse
Ils devront trouver comment modifier leur négatives.
programme.

99
Niveau intermédiaire - Déterminer la vitesse de MBot

N IVEAU INTERMÉDIAIRE - D ÉTERMINER LA VITESSE DE MBot

Activité élève

Durée Public Maths Sciences Algo

mesure et
incertitude ;
vitesse
conversions de
1h 2de linéaire ;
grandeurs
temps ;
distance ;
mouvement

ACTIVITÉ
Karim et Julien programment le robot MBot pour qu’il se dé-
place. Julien annonce à Karim :

« Lorsqu’on sélectionne avancer à la vitesse 100 , cela ne

correspond pas à 100 km/h mais à 100 m/s ! ! ! »

Ta Mission : Comment vérifier l’affirmation de Julien ?

Notes pour l’enseignant

M ÉTHODE R EMARQUE
En général, les élèves utilisent leur pro- Très peu attendent que le robot ait déjà at-
gramme du fichier « MBot1 », leur téléphone teint une certaine vitesse avant de démarrer
(pour mesurer le temps) et une règle (pour le chronomètre. Cela peut induire une ré-
déterminer une distance). flexion sur le mouvement accéléré puis uni-
La conversion des vitesses m/s et km/h est forme.
au centre de l’activité

100
 Vitesse de rotation avec MBot

D ESCRIPTION
Objectif
L’objectif du projet est de mettre en évidence, par l’expérimentation, l’influence du dia-
mètre d’une roue sur la vitesse linéaire d’un véhicule.
Il faut arriver à observer que, pour un même distance, l’augmentation du diamètre des
roues entraîne une diminution du temps de parcours du véhicule.
Autrement dit : la vitesse linéaire augmente lorsque le diamètre des roues augmente

Intérêt
Il est intéressant d’aborder le thème de sciences Comment passer de la vitesse des roues à la vi-
tesse du véhicule avec un robot. En effet :

Expérimentation et démarche scientifique l’élève manipule tout au long de l’activité, fait des hypo-
thèses et doit valider ses choix
Objet attrayant le robot Mbot reste attractif pour les élèves et sa programmation permet de valori-
ser le travail de l’élève

Matériel

— 1× MBot
— 1 × accès internet : IDE programmation par bloc [Link]

Remarques

M ÉTHODE
L’activité propose de mettre en évidence le lien entre variation du diamètre et variation
de vitesse linéaire.
Cette activité peut être prolongée par une vérification de la relation entre vitesse linéaire
(V ), rayon (r) et fréquence de rotation (N ) : V = 2 × π × r × N .
Pour cela il faudra utiliser un tachymètre permettant une mesure de la fréquence de rota-
tion.

101
Niveau initiation

N IVEAU INITIATION
Activité élève

Durée Public Maths Sciences Algo

mouvement,
durée, instructions
2h 2de
distance, déplacement
vitesse linéaire

ACTIVITÉ
Hélias veut booster son robot en changeant les roues. Il a trouvé sur
Internet de jolies roues jaunes pouvant s’adapter sur le MBot.
Ces nouvelles roues sont plus grandes et Hélias s’exclame : "En plus,
lorsque je sélectionnerai la vitesse 100, mon robot ira plus vite !".
Ta Mission : Comment vérifier si Hélias a raison, le robot ira-t-il vraiment plus
vite ?

Notes pour l’enseignant

M ÉTHODE R EMARQUE

1) La distance doit être suffisamment Les élèves utilisent leur téléphone (pour me-
grande pour mettre en évidence la va- surer le temps) et une règle (pour déterminer
riation de vitesse et suffisamment petite une distance).
pour éviter une dérive du robot. L’utilisation de la barre d’espace pour arrê-
ter le robot n’est pas indispensable mais est
2) Montrer l’intérêt de faire plusieurs fois la très pratique pour gérer l’arrêt du robot.
même mesure afin de mettre évidence
la variabilité d’une mesure.
3) Proposition de code :

102
 Variation de vitesses avec MBot

D ESCRIPTION
Objectif

Le but de ce projet est d’abord de déterminer par l’expérimentation la nature accéléré,

décéléré ou uniforme du mouvement d’un mobile qui avance à l’aide d’un algorithme.
Dans un deuxième temps, l’élève doit modifier l’algorithme pour animer le mobile d’un
mouvement décéléré puis valider expérimentalement l’hypothèse.

Intérêt
Il est intéressant d’aborder le thème de sciences Comment peut-on décrire le mouvement d’un
véhicule avec un robot. En effet :

Expérimentation et démarche scientifique l’élève manipule tout au long de l’activité, fait des hypo-
thèses et doit valider ses choix
Analyse et modification d’un algorithme l’algorithme de départ n’étant pas assez simple, l’élève
doit émettre une hypothèse à partir de l’analyse de l’algorithme et ensuite le modifier pour
changer le mouvement du robot

Matériel

— 1× MBot
— 1 × accès internet : IDE programmation par bloc [Link]

Remarques

M ÉTHODE M ÉTHODE
1) Lecture de l’algorithme par les élèves 1) Modification de l’algorithme pour obte-
2) Hypothèses des élèves (individuelle- nir un mouvement décéléré
ment et/ou par groupe) sur la nature 2) Manipulation / Observation
du mouvement 3) Validation / Conclusion
3) Proposition de protocole permettant
de valider l’hypothèse (mesure de vi-
tesse à partir de durée et distance)
4) Manipulation / Observation
5) Validation / Conclusion

103
Niveau initiation - Nature du mouvement

N IVEAU INITIATION - N ATURE DU MOUVEMENT

Activité élève

Durée Public Maths Sciences Algo

instruction
mouvement,
déplacement,
2h 2de calcul durée, vitesse,
boucles, incré-
distance
mentation

ACTIVITÉ
Un véhicule autonome est apte à avancer sans l’intervention du
conducteur.
Il emploie des algorithmes pour décider de l’action à réaliser sur les
commandes du véhicule.
Le robot MBot se déplace suivant le même principe. Il est aussi équipé d’un émetteur et
d’un récepteur à ultrason qui permet de déterminer la distance du robot par rapport à
un obstacle.
Le code ci-dessous a été envoyé dans le robot.

Ta Mission : Détermine la nature du mouvement.

104
Niveau expert - Mouvement décéléré

N IVEAU EXPER T - M OUVEMENT DÉCÉLÉRÉ

Activité élève

Durée Public Maths Sciences Algo

instruction
mouvement,
déplacement,
2h 2de calcul durée, vitesse,
boucles, incré-
distance
mentation

ACTIVITÉ
Quand le robot exécute l’algorithme ci-dessous, la distance en cen-
timètre entre l’obstacle et le robot s’affiche en fonction du temps (en
seconde).

Ta Mission : Modifie le code pour que ton robot MBot ait un mouvement décéléré.
Vérifie alors expérimentalement que ton robot obéit !

105
 Normal ou truqué ? avec STM32
Éducation

D ESCRIPTION
Objectif
Cette activité propose à l’élève de travailler sur la fluctuation d’échantillonnage.
Sans accéder au code, seulement en manipulant la carte STM32 Éducation, l’élève doit
déterminer si le jeu téléversé est un jeu normal ou truqué. . .

Intérêt
L’intérêt de cette activité est de pouvoir, en toute liberté, créer des situations équiprobables ou non.
Même s’il est possible d’utiliser de vrais dès truqués, l’utilisation d’une carte STM32 Éducation permet
un éventail très larges de situations.
Ici le choix a été fait de procéder à un tirage aléatoire (ou non ;) ) d’un nombre entre 0 et 9 (inclus).

Matériel

— 1× STM32 Éducation (facultatif car le simulateur peut suffire)

— 1 × accès internet : IDE programmation par bloc [Link]

Progression
L’activité se déroule en 2 temps :
Analyse du programme Dans cette partie, l’élève doit étudier les deux programmes possibles (tru-
qué ou non) puis répondre à une série de questions de probabilités
Expérience aléatoire Ensuite l’élève manipule la carte STM32 Éducation et effectue un certain nombre
d’expériences aléatoires. Dans cette partie l’analyse des échantillons et la création d’une re-
présentation graphique permettra de conclure sur le type de programme téléversé.

106
Activité

ACTIVITÉ
Activité élève

Durée Public Maths Sciences Algo

fluctuation
2h 2de ; term
d’échantillage

ACTIVITÉ
Normal ou truqué ?
Sur votre carte est téléversé un des deux programmes de jeu suivant.
Quand le joueur gagne, il a un smiley sourire, sinon il a une croix.

Jeu normal Jeu truqué

Analyse du programme

1) Si on choisit un nombre entier au hasard entre 0 et 9, combien y-a-t-il d’issues pos-

sibles ?
2) Si pour gagner il faut obtenir un nombre entre 0 et 4, combien y-a-t-il d’issues favo-
rables ?
3) Calculer la probabilité de gagner avec la version normale du programme. Donner
le résultat sous forme de fraction, de nombre décimal et de pourcentage.
4) Avec le même raisonnement, calculer la probabilité de gagner avec la version tru-
quée du programme. Donner le résultat sous forme de fraction, de nombre décimal
et de pourcentage.

107
Activité

Analyse du programme

5) Jouer des parties par séquence de 25 parties et noter G pour gagner et P pour
perdu, dans votre cahier.
6) En utilisant vos résultats, compléter le tableau ci-dessous. Attention ! Bien prendre son
temps pour compter.

7) Compléter le graphique correspondant à la dernière ligne du tableau : placer un

point par colonne, relier les points par des segments et légender les axes.
Donner un titre au graphique.

8) Analyser le graphique et conclure sur le programme qui est téléchargé dans votre
carte.
Argumenter avec une ou plusieurs phrases.

Notes pour l’enseignant

R EMARQUE
Le code interactif est accessible en ligne :

Jeu normal [Link]

Jeu truqué [Link]

108
 Pile ou face avec STM32 Éducation

D ESCRIPTION
Objectif
https ://[Link]/8232568565gwgstdqzhjfk Le but de ce projet est de simuler
une expérience aléatoire de lancer de pièce avec une carte STM32 Éducation.

Intérêt
Bien évidemment, travailler avec une carte STM32 Éducation n’exclut pas de réaliser des expériences
aléatoires réelles (pièces, dés, etc.). Cependant, il est très intéressant pour l’enseignant d’utiliser des
STM32 Éducation dans cette partie du programme.
Simplicité de la situation. La situation est très simple à expliquer et les élèves comprennent le but à
atteindre. L’absence de difficulté mathématique rend cette situation particulièrement simple à
mettre en œuvre.
Motivation des élèves. L’envie de programmer un objet connecté est grande pour les élèves. Cette
façon de programmer, utile, concrète et appliquée, leur correspond parfaitement.
De nombreuses solutions/améliorations possibles. Comme pour bien des projets, il y a plusieurs
façons d’arriver à la solution. Par ailleurs, les élèves peuvent apporter ou proposer de nom-
breuses améliorations. La programmation par bloc, exempte de difficulté syntaxique, est parti-
culièrement adaptée à la créativité.
Travail mathématique sur la modélisation. Cette compétence n’est pas facile à mettre en œuvre.
Ici, l’absence de difficultés mathématiques rend ce travail beaucoup plus accessible à tous.
Initiation aux différents capteurs Aux travers cette activité on peut commencer à utiliser l’accéléro-
mètre (en secouant la carte) , le magnétomètre (en approchant un aimant ) etc..

Matériel

— 1× STM32 Éducation (facultatif car le simulateur peut suffire)

— 1 × accès internet : IDE programmation par bloc [Link]

109
Progression proposée

P ROGRESSION PROPOSÉE

M ÉTHODE
Voici la progression proposée aux élèves. L’objectif est atteint dès la troisième étape. Les
étapes suivantes, de niveau expert, sont du bonus.
1) Initiation - Premier modèle.

Afficher un 0 ou un 1 de façon aléatoire. Pour préparer la suite et pour plus de lisibi-

lité, nous proposons dès maintenant de créer et d’utiliser la fonction nTirage.
2) Intermédiaire - Pile ou Face.

Afficher un p ou un f de façon aléatoire.

3) Intermédiaire - 16 tirages.

Afficher d’un coup 16 tirages aléatoires. Nous donnons à l’élève une nouvelle fonc-
tion : efface. Elle permet d’effacer l’écran LCD avant chaque tirage (sinon on voit
rien). De plus, le fond d’écran chage de couleur de façon aléatoire (c’est fun !)
4) Expert - Initialisation.

Ajouter la fonction initialisation qui lance 10 fois la fonction efface (ce qui
fait une petite animation de couleurs). Utiliser cette fonction pour initialiser STM32
Éducation au démarrage et lors d’un appui long sur le bouton.
5) Expert - 32 tirages.

Afficher maintenant les tirages sur 2 lignes.

6) Expert - Enregistrer les effectifs.

Création de deux variables nP et nF qui stockent le nombre total de piles et de faces

obtenues. Afficher les valeurs de ces variables sur l’écran. Pour cela, effectuer seule-
ment 10 tirages aléatoires par ligne (au lieu de 16) afin de laisser la place pour l’affi-
chage de 5 caractères.

110
Niveau initiation - Premier modèle

N IVEAU INITIATION - P REMIER MODÈLE

Activité élève

Durée Public Maths Sciences Algo

affichage ;
expérience
0,5 h 2de événement ;
aléatoire
fonction

ACTIVITÉ
Mission : utiliser vos STM32 Éducation pour jouer à Pile ou Face!

Connectez vous sur l’interface de programmation de votre STM32

Éducation ([Link]
Utiliser les instructions ci-dessous pour simuler un jeu de pile ou face.

Notes pour l’enseignant

R EMARQUE
M ÉTHODE
La proposition de so-
Proposition de résolution :
lution interactive est
accessible en ligne
[Link]
_EMYM0YfT11A6.

111
Niveau intermédiaire - Pile ou Face

N IVEAU INTERMÉDIAIRE - P ILE OU FACE

Activité élève

Durée Public Maths Sciences Algo

affichage ;
expérience événement ;
0,5 h 2de
aléatoire fonction ;
condition

ACTIVITÉ
Mission : améliorer votre simulateur
Utiliser les blocs ci-dessous pour remplacer les 0 et les 1 par des p ou
f.

112
Notes pour l’enseignant

N OTES POUR L’ ENSEIGNANT

M ÉTHODE R EMARQUE
Proposition de résolution : La proposition de solution interactive est
accessible en ligne [Link]
_MysE701XAHpo.

113
Niveau intermédiaire - 16 tirages

N IVEAU INTERMÉDIAIRE - 16 TIRAGES

Activité élève

Durée Public Maths Sciences Algo

affichage ;
événement ;
expérience
0,5 h 2de fonction ;
aléatoire
condition ;
boucle

ACTIVITÉ
Mission finale : utiliser la puissance de l’électronique pour
effectuer 16 tirages simultanés !
En vous aidant des
instructions proposées,
modifier votre programme
pour afficher
simultanément 16 tirages
sur la première ligne.
N’oubliez d’ajouter la
fonction efface qui permet
d’effacer l’écran LCD de
votre STM32 Éducation.

114
Niveau intermédiaire - 16 tirages

M ÉTHODE R EMARQUE
Proposition de résolution : La proposition
de solution in-
teractive est
accessible en
ligne https:
//[Link]/
_711WJtAupKRX.

115
Niveau expert - Initialisation

N IVEAU EXPER T - I NITIALISATION

Activité élève

Durée Public Maths Sciences Algo

affichage ;
événement ;
expérience
0,5 h 2de fonction ;
aléatoire
condition ;
boucle

ACTIVITÉ
Mission experte 1/3 : initialiser la carte
Afin de préparer
les améliorations
à venir, créez une
nouvelle fonction
initialisation.
Elle doit exécuter
10 fois la fonction
efface, ce qui
fait très jolie avec
l’écran coloré !
Cette fonction
initialisation
sera appelée
au démarrage
de votre STM32
Éducation et aussi
lors d’un appui
long sur le bou-
ton.

116
Niveau expert - Initialisation

M ÉTHODE R EMARQUE
Proposition de résolution : La proposition
de solution in-
teractive est
accessible en
ligne https:
//[Link]/
_c3mKWL3fFX6A.

117
Niveau expert - 32 tirages

N IVEAU EXPER T - 32 TIRAGES

Activité élève

Durée Public Maths Sciences Algo

affichage ;
événement ;
expérience
0,5 h 2de fonction ;
aléatoire
condition ;
boucle

ACTIVITÉ
Mission experte 2/3 : Plus de tirages !
Utiliser les instructions ci-dessous pour effectuer les 32 tirages : 16 sur
la première ligne de l’écran et 16 sur la seconde.

118
Niveau expert - 32 tirages

M ÉTHODE R EMARQUE
Proposition de résolution : La proposition
de solution in-
teractive est
accessible en
ligne https:
//[Link]/
_F8MKCVD2jDY8.

119
Niveau expert - Enregistrer les effectifs

N IVEAU EXPER T - E NREGISTRER LES EFFECTIFS

Activité élève

Durée Public Maths Sciences Algo

affichage ;
événement ;
expérience fonction ;
0,5 h 2de
aléatoire condition ;
boucle ;
variables

ACTIVITÉ

Mission experte 3/3 : La totale !

Pour finir, créer 2 variables nP et nF
qui vont compter le nombre total
de piles et de faces obtenus.
Sur chaque ligne, n’effectuer plus
que 10 tirages afin de laisser la
place pour afficher les valeurs de
ces variables.

120
Niveau expert - Enregistrer les effectifs
M ÉTHODE
Proposition de résolution :

R EMARQUE
La proposition de solution interactive est accessible en ligne [Link]
_VEy38D1iC07g.

121