Introduction

Bonjour à toi jeune programmeuse !

Je suis Joseph Marchand, c’est moi qui vais t’apprendre à créer tes propres programmes informatiques à travers différents TP. Avant de commencer, sache que tu seras accompagnée par mes fidèles acolytes : les organisateurs. Ce sont eux qui me remplacent pour répondre à tes questions alors n’hésite pas ! Tout au long du stage, tu vas pouvoir jouer avec un micro:bit !

Qu’est-ce qu’un micro:bit ?

C’est un microcontrôleur de la taille d’une carte à jouer sur lesquels nous pouvons écrire des programmes. Tu vas pouvoir intéragir avec les composants du micro:bit comme l’écran de LED ou les boutons. Il existe plein d’autres manières d’utiliser la carte programmable, que tu vas apprendre tout au long du stage !

Ton premier programme

Analysons un programme

Un programme en Python est une série d’instructions exécutées par un ordinateur (ou dans notre cas par le micro:bit). Retiens que chacune d’entre elle doit être écrite sur une nouvelle ligne et que l’ordinateur lira le programme de haut en bas.

Comme premier exemple, analysons ce programme. Tu peux utiliser les flèches à gauche et à droite de la boîte ci-dessous pour parcourir le code !

    

    




1
2
3
4
5


# Début du programme

# Importe les fonctions pour le micro:bit
from microbit import *
 





6


display.set_pixel(0, 2, 9)





7


sleep(500)





 8
 9
10
11
12
13
14
15
16


display.set_pixel(1, 2, 9)
sleep(500)
display.set_pixel(2, 2, 9)
sleep(500)
display.set_pixel(3, 2, 9)
sleep(500)
display.set_pixel(4, 2, 9)

# Fin du programme




    

Essaye d’envoyer ce programme sur ton micro:bit ! Pour cela, rends toi sur le site https://python.microbit.org . Une fois envoyé sur la carte programmable, le programme devrait afficher une barre de chargement sur la ligne de diodes centrales.

Les fonctions de contrôle du micro:bit

Comme tu l’as vu plus tôt, il existe des fonctions qui permettent de contrôler le micro:bit. Nous allons ici te présenter les principales.

Allumer des LEDs

Il existe de nombreuses façons d’afficher quelque chose sur l’écran du micro:bit. La première, et la plus basique, consiste à choisir les LEDs que l’on veut allumer et à les allumer une par une.

Pour cela, tu l’as vu juste avant, on utilise la fonction display.set_pixel(colonne, ligne, intensite), où :

• colonne représente le numéro de la colonne de la LED à allumer
• ligne représente le numéro de la ligne de la LED à allumer
• intensite représente l’intensité avec laquelle la LED va s’allumer (de 0 pour éteindre la LED à 9 pour l’allumer à pleine puissance).

Voici un petit exemple de l’utilisation de la fonction :

1
2
3
4
5
6

# Importe les fonctions pour le micro:bit
from microbit import *

# Allume le pixel de la 5ème colonne et 3ème ligne à une intensité de 9
# car on commence à compter à partir de 0
display.set_pixel(4, 2, 9)

Si tu essayes d’envoyer ce code vers le micro:bit, tu devrais avoir ce résultat :

Comme tu peux le remarquer avec l’image ci-dessus, les lignes et les colonnes sont numérotées entre 0 et 4 ! Cela signifie donc que la première ligne est numérotée 0, la deuxième est numérotée 1, etc.

Mini-mission 1 : Dessiner un coeur

Pour savoir si tu as bien compris cette partie, dessine nous un cœur !

Ça devrait ressembler à quelque chose comme ça :

Les images

Pour afficher des images et des symboles déjà existants, on utilisera cette fonction : display.show(Image.NOM_IMAGE), où NOM_IMAGE est le nom anglais d’une image pré-enregistrée. Tu peux trouver la liste des images pré-enregistrées ici .

Voici à quoi ressemblent les images HEART et HAPPY :

Et le texte ?

La fonction pour afficher du texte sur l’écran s’appelle display.scroll(message), où message est la chaîne de caractères que tu veux afficher.

1
2
3
4

# Importe les fonctions pour le micro:bit
from microbit import *

display.scroll("Je suis Joseph Marchand !")

Les variables

La plupart du temps, nous avons besoin de stocker des informations dans notre code. On parle alors de variables. Elles permettent de ranger des choses et de pouvoir les ressortir quand on le souhaite. Ce sont des éléments qui associent un nom à une valeur. C’est comme si on utilisait des boîtes pour ranger des éléments !

Pour déclarer une variable en Python, on procède de la sorte :

1
2
3
4
5
6
7
8

# Importe les fonctions pour le micro:bit
from microbit import *

# Déclaration de `ma_variable`, qui stocke la valeur 42
ma_variable = 42

# Affiche la valeur de `ma_variable`
display.scroll(ma_variable)

Tu peux mettre à jour une variable grâce à sa valeur actuelle. Pour comprendre un peu mieux, voici un petit exemple :

    

    




1
2


from microbit import *
 





3


nombre = 10





4
5


display.scroll(nombre)
 





6


nombre = nombre + 1





7


display.scroll(nombre)




    

On peut caractériser les variables en différents types.

Types de variables

Nombres

Comme leur nom l’indique, il s’agit tout simplement de nombres (positifs ou négatifs). On peut donc faire des opérations dessus avec les opérateurs suivants :

Clique ici pour découvrir ce que sont une division entière et un modulo !

Les deux dernières opérations ne te sont peut-être pas familières, et c’est normal, mais elles ne sont pas compliquées. Elles correspondent aux résultats de la division euclidienne. Voici un petit exemple :

• La division entière (//) correspond au quotient de la division, ici 3.
• Le modulo (%) correspondent au reste de la division, ici 2.

Voici un petit mémo qui te permettra de comprendre ces opérations, avec le même exemple.

Appuie sur le bouton Run pour exécuter le code python ci-dessous

a = 17 b = 5 print("Quotient = ") print(a // b) print("Reste = ") print(a % b) Run

Le résultat :

Si tu as des questions, n’hésite pas à demander de l’aide à un organisateur.

Chaînes de caractères

On peut créer du texte en mettant son contenu entre guillemets (par exemple : mon_texte = "Bonjour tout le monde !"). On peut aussi attacher des morceaux de texte entre eux avec le symbole + (par exemple : mon_texte = "Bonjour" + " !").

    

    




1


texte  = "Bonjour" + " !"





2


print(texte)




    

À noter qu’il est souvent très pratique de convertir un nombre en texte pour ensuite l’incorporer dans une phrase, on peut faire ça avec la fonction str(nombre).

1
2
3
4
5
6

# Importe les fonctions pour le micro:bit
from microbit import *

nombre_de_patates = 42
texte = "Il y a " + str(nombre_de_patates) + " patates !"
display.scroll(texte)

Création Variable nombre_de_patates.

Conversion de nombre_de_patates en texte.

Concaténation des textes.

Le résultat.

Booléens

Enfin, les booléens servent à exprimer le vrai ou le faux. Il n’y a que deux valeurs possibles pour ce type de variables : True (vrai) et False (faux).

Comme pour les nombres, il existe différentes opérations qui te renverront un booléen :

1
2
3
4
5

# Importe les fonctions pour le micro:bit
from microbit import *

# Affiche si 42 est égal à 42
display.scroll(42 == 42)

Tu vas pouvoir également utiliser des opérateurs directement sur des valeurs booléennes :

Comment utiliser les boutons du micro:bit ?

Comme tu peux le voir, il y a deux boutons physiques sur le micro:bit : le bouton A (1) et le bouton B (2). Il existe également un bouton tactile (3) au niveau du logo au-dessus de l’écran.

Pour utiliser les boutons A et B, tu peux respectivement utiliser la fonction button_a.get_presses() et button_b.get_presses(). Ces fonctions renvoient le nombre d’appuis sur le bouton depuis la dernière fois qu’elles ont été appelées. Par exemple, ce code va prendre le nombre de fois que le bouton A a été appuyé au cours des 5 premières secondes du programme :

1
2
3
4
5
6
7
8

# Importe les fonctions pour le micro:bit
from microbit import *

# Attend 5 secondes
sleep(5000)

# Affiche le nombre d'appuis
display.scroll(button_a.get_presses())

En ce qui concerne le bouton tactile, tu peux détecter si tu appuies dessus en utilisant la fonction pin_logo.is_touched(), qui renvoie un booléen (True ou False).

Un exemple un peu plus complexe

À toi de jouer ! Que fais le programme d’après toi ? Essaye de le lancer sur ton micro:bit !

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Importe les fonctions pour le micro:bit
from microbit import *

# Compte à rebours
display.set_pixel(0, 2, 9)
sleep(500)
display.set_pixel(1, 2, 9)
sleep(500)
display.set_pixel(2, 2, 9)
sleep(500)
display.set_pixel(3, 2, 9)
sleep(500)
display.set_pixel(4, 2, 9)

# Attends 5 secondes
sleep(5000)

# Récupère le nombre d'appuis sur le bouton A
a = button_a.get_presses()

# Affiche le score
display.scroll("Score : " + str(a))

Et si…

Avant de continuer…

Avant d’attaquer la suite, il est primordial de comprendre ce qu’est l’indentation. Elle permet de définir des blocs. Chaque ligne avec la même indentation fait donc partie du même bloc.

Pour créer ces blocs, nous allons utiliser la touche tabulation sur ton clavier. Elle permet de rajouter des espaces. Elle devrait ressembler à ça :

L’indentation correspond au nombre d’espaces au début d’une ligne et avant une instruction. Dans l’exemple de code ci-dessous, la première ligne a un niveau d’indentation de 0 espaces en début de ligne, tandis que la troisième ligne a un niveau d’indentation de 4 espaces.

1
2
3

display.scroll("Coucou") # Ligne qui n'est pas indentée
if True:
    display.show(Image.HAPPY) # Ligne qui est indentée 1 fois

Garder l’indentation permet de faire plusieurs instructions dans le même bloc.

Revenons à nos conditions

Maintenant que tu sais utiliser des variables et plusieurs fonctions de contrôle du micro:bit, tu vas pouvoir faire réagir ton programme en fonction de toutes ces données dans cette partie. Eh bien ça tombe bien, car Python sait faire ça grâce aux instructions if, elif et else.

L’instruction if correspond au mot “si” en français, que l’on fait suivre d’une condition que l’on veut tester. Elle permet d’exécuter un morceau de code que lorsqu’une condition est vraie. Ce sont les mêmes conditions que celles décrites dans la section “Booléens” de la partie sur les types de variables.

Pour écrire une condition, la syntaxe est : if condition: suivi d’un bloc de code indenté. Le bloc de code en question ne sera alors exécuté que si condition s’évalue à True, c’est-à-dire qu’elle doit être vraie.

Essaye d’exécuter ce code en cliquant sur le bouton Run !

Un if peut être accompagné d’un else (“sinon” en français) qui exécute un bloc de code uniquement si la condition du if est fausse.

Enfin, il y a aussi le elif qui est la contraction du else et du if. Il n’est exécuté que si sa condition est vraie et que les conditions précédentes sont fausses.

Voici un petit exemple pour illustrer ce que l’on dit sur les conditions :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Importe les fonctions pour le micro:bit
from microbit import *

x = 0

if x < 30:
    display.scroll("Pomme")
elif x < 50:
    display.scroll("Poire")
elif x < 80:
    display.scroll("Banane")
else:
    display.scroll("Orange")

Si jamais tu as une question ou s’il y a quelque chose que tu n’as pas compris, n’hésite pas à demander aux organisateurs.

Ça fait beaucoup de lignes

Tu sais maintenant comment créer des programmes assez complexes. Pour répéter une action et t’éviter de copier-coller des bouts de code, il existe en Python ce que l’on appelle des boucles. Il en existe deux : les boucles for et les boucles while. Nous allons commencer par la dernière.

Tant que

La boucle while (“tant que”) est une boucle dont le bloc de code est répété tant qu’une condition est vérifiée (d’où son nom). On l’écrit similairement à des conditions while condition:. Illustrons cette boucle à travers un exemple de code :

    

    




1
2


from microbit import *
 





3


while button_a.get_presses() == 0:





4
5
6


    # Ce qui suit va être répété tant que le button A n'a pas été appuyé
    display.show(Image.ANGRY)
 





7


display.scroll("Tu es sortie !")




    

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Importe les fonctions pour le micro:bit
from microbit import *

while True:
    # Vérifie tout le temps si le bouton A est appuyé ou non
    if button_a.is_pressed():
        display.show(Image.HAPPY)

    else:
        # Affiche `ANGRY` si le bouton n'est pas appuyé
        display.show(Image.ANGRY)

Pour un certain nombre de fois

La boucle for est un peu différente de la boucle while, car elle permet de répéter un bloc de code un nombre fini de fois. Ce nombre de répétitions doit être connu pour pouvoir utiliser ce type de boucle.

Voyons le fonctionnement de ce type de boucles à travers de plusieurs exemples. Tu peux cliquer sur les flèches pour avoir les explications et à la fin, lancer les programmes !

Les boucles simples

Le nombre dans les parenthèses de range indique le nombre de répétitions, ici la boucle répète 3 fois le bloc de code en-dessous.

1
2
3

for i in range(3):
    # Affiche "Test."
    print("Test.")

La variable de la boucle for

La variable i indique le numéro de la répétition, en partant de 0, la boucle fera 5 répétitions.

i étant une variable, tu peux changer son nom si tu as envie :

Voici un petit schéma pour bien différencier les différents blocs de code :

Projet

Il est maintenant temps de mettre en pratique tout ce que tu as appris au cours de ce TP avec un petit projet. Rien de compliqué, je te rassure, et puis si tu as des questions, les organisateurs sont là pour ça !

But

Joseph est dans la panade… Il aurait besoin de deux dés à 6 faces pour jouer au Monopoly avec ses amis, mais il les a oubliés, et tout ce qu’il a à sa disposition est un micro:bit…

Joseph te demande alors de lui faire un programme qui simule un lancé de deux dés et affiche la valeur des deux dés lorsque le bouton A ou le bouton B est appuyé.

Cependant, comme Joseph ne veut pas que ses amis pensent qu’il a simplement oublié les vrais dés, il voudrait donc y ajouter quelques fonctionnalités :

• Il voudrait que si le lancé est un double (les 2 dés sont les mêmes), un smiley content s’affiche juste après les chiffres :

• Par contre, il voudrait que si trois doubles sont faits d’affilée, un smiley pas content s’affiche à la place du smiley content :

• Il voudrait enfin que le smiley disparaisse 2 secondes après être apparu

On te conseille vivement de faire ce projet étape par étape. Tu peux commencer par coder le lancé des deux dés, et lorsque cela fonctionne, ajouter les différentes demandes de Joseph les unes après les autres.

Voici un petit exemple avec les lancés de dés :

De plus, n’hésite pas à poser des questions si tu es bloquée, les organisateurs seront très contents de t’aider !

Conclusion

Voili voilou, je crois que mon rôle touche à sa fin. Si quelque chose ne te semble pas clair, pose la question aux organisateurs ! Tu peux nous faire part de tes remarques pour améliorer ce TP et le rendre encore plus clair.

Mais ce n’est pas parce que ce TP est terminé que tu es lachée dans la nature pour autant. Il te reste encore plein de trucs à découvrir, que ce soit en Python ou bien en rapport au micro:bit. Tu as de nombreux autres TPs qui sont disponibles. Ils se présentent plutôt sous la forme de petits projets centrés sur l’utilisation d’un composant en particulier du micro:bit. Tu peux ainsi apprendre à utiliser pleinement le micro:bit pour ensuite créer tes propres projets !

Nous t’invitons donc à choisir les projets qui t’intéressent et avancer à ton rythme !