Python avancé avec la micro:bit

0 Partages

Tu as déjà appris les bases de Python et tu veux aller plus loin ? Avec la micro:bit, tu vas coder des jeux, des calculatrices, des capteurs, et bien plus encore.
Tu vas manipuler des boucles, des fonctions, des événements, et même des conversions de bases (binaire, hexadécimal, etc.) — des compétences utiles pour le lycée, les études, et même dans le monde professionnel.
La micro:bit interagit avec le monde réel grâce à ses boutons, ses capteurs et son écran LED. Tu pourras voir le résultat de ton code en temps réel !

Partie 01 : Découverte des tables en Python

Apprendre à utiliser et manipuler des tables (ou listes) en Python, en affichant une séquence de chiffres ou d’images sur l’écran de la micro:bit.

Une table en Python s’écrit entre crochets : [ ].
Les éléments sont séparés par des virgules.
Pour afficher une image, utilise Image.NOM_DE_L_IMAGE (ex : Image.SMILE).

from microbit import *

while True:
    all_images = [str(1), str(2), str(3)]
    display.show(all_images, delay=300)

Modifie le programme suivant pour qu’il affiche, dans l’ordre, les chiffres de 1 à 5 sur l’écran de la micro:bit, avec un délai de 300 ms entre chaque chiffre.

Comprendre la table all_images Actuellement, la table all_images contient les chaînes de caractères "1", "2" et "3". Question : Comment faire pour qu’elle contienne les chiffres de 1 à 5 ?
Modifier la table Ajoute les chiffres manquants ("4" et "5") dans la table all_images.
Tester le programme Télécharge ton programme sur la micro:bit et vérifie que les chiffres défilent bien de 1 à 5.
Personnalisation (défis bonus !)
- Défi 1 : Fais défiler les chiffres de 5 à 1.
- Défi 2 : Crée ta propre table avec des motifs ou des lettres (ex : "A", "B", "C").
- Défi 3 : Remplace les chiffres par des images (ex : Image.HAPPY, Image.SAD, Image.HEART).

Crée une animation graphique :

from microbit import *

while True:
    image1 = Image("99999:"
                  "90009:"
                  "90009:"
                  "90009:"
                  "99999")
    image2 = Image("00000:"
                   "09990:"
                   "09090:"
                   "09990:"
                   "00000")
    image3 = Image("00000:"
                   "00000:"
                   "00900:"
                   "00000:"
                   "00000")
    image4 = Image("00000:"
                   "00000:"
                   "00000:"
                   "00000:"
                   "00000")
    image5 = Image("99999:"
                  "99999:"
                  "99999:"
                  "99999:"
                  "99999")
    all_images = [image1, image2, image3, image4, image5]
    display.show(all_images,delay=300)

Partie 02 : Chronomètre avec la micro:bit – booléens et gestion du temps

Découvrir le fonctionnement d’une variable booléenne (True/False) et la gestion du temps en Python, en créant un chronomètre qui se lance et s’arrête quand on touche le logo de la micro:bit

from microbit import *
import time

start = 0
triggered = False

while True:
    if pin_logo.is_touched():
        triggered = not triggered
        while pin_logo.is_touched():
            start = time.ticks_ms()
          
    else:
        if triggered :
            display.scroll(int((time.ticks_ms() - start)/1000))
        else:
            display.show(Image.HEART)

Comprendre la variable booléenne triggered
- triggered vaut False au début : le chronomètre est arrêté.
- Quand on touche le logo, triggered devient True (chronomètre lancé), et redevient False si on retouche le logo (chronomètre arrêté).
- Question : Que fait l’instruction triggered = not triggered ?
Lancer et arrêter le chronomètre
- Si triggered est True, le chronomètre doit compter les secondes.
- Si triggered est False, le chronomètre doit s’arrêter.
Afficher le temps écoulé
- Utilise time.ticks_ms() pour mesurer le temps en millisecondes.
- Convertis ce temps en secondes et affiche-le sur l’écran.
Tester le programme
- Télécharge ton programme sur la micro:bit.
- Vérifie que le chronomètre se lance et s’arrête bien en touchant le logo.

Chronomètre lancé :

Défis bonus

Défi 1 : Ajoute un bouton pour remettre le chronomètre à zéro.
Défi 2 : Lance une musique toutes les secondes.
Défi 3 : Lance une musique toutes les 10 secondes.

from microbit import *
import time
import music

start = 0
triggered = False

while True:
    if pin_logo.is_touched():
        triggered = not triggered
        while pin_logo.is_touched():
            start = time.ticks_ms()

    elif button_a.is_pressed():
        while button_a.is_pressed() :
            start = time.ticks_ms()
          
    else:
        if triggered :
            duration = int((time.ticks_ms() - start)/1000)
            music.pitch(200, 50)
            if (duration % 10) == 0:
                music.pitch(300, 80)
            display.scroll(duration)
        else:
            display.show(Image.HEART)

Partie 01 : Convertisseur décimal

Consigne : Écrire un programme Python qui demande à l’utilisateur de saisir un nombre entier décimal, puis affiche sa représentation en base dans une base de 2 à 36.

Exemple : Pour une conversion en base 16 (hexadécimal), si l’utilisateur saisit 10, le programme doit afficher E.

Indices pour réussir l’exercice

Comprendre par exemple pour la base 16 : En hexadécimal, on utilise les chiffres de 0 à 9 et les lettres A à F pour représenter les valeurs de 10 à 15.
Méthode de conversion : Pour convertir un nombre décimal en hexadécimal, on divise successivement le nombre par 16 et on garde le reste de chaque division.
Utilisation des restes : Chaque reste correspond à un chiffre hexadécimal, mais il faut les lire à l’envers à la fin.
Gestion des lettres : Si un reste est égal à 10, 11, 12, 13, 14 ou 15, il faut le remplacer par A, B, C, D, E ou F.

Exemple de programme :

from microbit import display, Image, button_a, pin_logo

# base donnée (2 ≤ base ≤ 36)
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
base = 16

def decimal_to_base_n(decimal_num, base):
    """
    Convertit un nombre décimal (int) dans une base donnée (2 ≤ base ≤ 36).
    Retourne une chaîne représentant le nombre dans la base souhaitée.
    """
    if base < 2 or base > 36:
        raise ValueError("La base doit être comprise entre 2 et 36.")

    result = []

    if decimal_num == 0:
        return "0"

    decimal_num = abs(decimal_num)

    while decimal_num > 0:
        # Obtenir le reste de la division entière du nombre par la base
        remainder = decimal_num % base
        result.append(digits[remainder])
        decimal_num = decimal_num // base

    return ''.join(reversed(result))
    
# Addition de deux nombres
i = 0
display.show(Image.PACMAN)

while True:
    # Résultat de l'addition
    if pin_logo.is_touched():
        display.show("=" + decimal_to_base_n(i, base))
        i = 0
        while pin_logo.is_touched():
            pass
    # Choix d'un nombre avec le bouton A
    elif button_a.is_pressed():
        i = i+1
        display.show(str(i))
        while button_a.is_pressed() :
            pass

Choisis avec le bouton A le chiffre 10 :

Convertis le chiffre 10 en décimal en base 16 avec la zone sensitive :

Partie 02 : Calculette de programmeur

Tu vas programmer une micro:bit pour qu’elle fonctionne comme une calculette permettant d’additionner deux nombres dans une base choisie (entre 2 et 36). Par exemple, si la base est 16, tu pourras additionner deux chiffres hexadécimaux (comme A + 5 = F).

Consignes

Reprend la Fonction de conversion de l’exercice précédent decimal_to_base_n(decimal_num, base) qui convertit un nombre décimal en une chaîne de caractères représentant ce nombre dans la base choisie.
- Exemple : decimal_to_base_n(15, 16) doit retourner "F".
Choix de la base La variable base est déjà initialisée à 16, mais tu pourras la changer pour tester d’autres bases (entre 2 et 36).
Sélection des nombres
- Appuie sur le bouton A pour incrémenter le premier nombre (i) et l’afficher.
- Appuie sur le bouton B pour incrémenter le deuxième nombre (j) et l’afficher.
- Les nombres doivent rester inférieurs à la base choisie.
Affichage du résultat
- Touche le logo de la micro:bit pour afficher le résultat de l’addition i + j dans la base choisie, sous la forme =X (où X est le résultat de l’addition de i + J).
Réinitialisation Après chaque calcul, les nombres i et j doivent être remis à zéro.

from microbit import display, Image, button_a, button_b, pin_logo

# base donnée (2 ≤ base ≤ 36)
digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
base = 16

def decimal_to_base_n(decimal_num, base):
    """
    Convertit un nombre décimal (int) dans une base donnée (2 ≤ base ≤ 36).
    Retourne une chaîne représentant le nombre dans la base souhaitée.
    """
    if base < 2 or base > 36:
        raise ValueError("La base doit être comprise entre 2 et 36.")

    result = []

    if decimal_num == 0:
        return "0"

    decimal_num = abs(decimal_num)

    while decimal_num > 0:
        # Obtenir le reste de la division entière du nombre par la base
        remainder = decimal_num % base
        result.append(digits[remainder])
        decimal_num = decimal_num // base

    return ''.join(reversed(result))
    
# Addition de deux nombres
i = 0
j = 0
display.show(Image.PACMAN)

while True:
    # Résultat de l'addition
    if pin_logo.is_touched():
        display.show("=" + decimal_to_base_n(i+j, base))
        i, j = 0, 0
        while pin_logo.is_touched():
            pass

    # Choix d'un nombre avec le bouton A
    elif button_a.is_pressed():
        i = i+1 if i < base-1 else 0
        display.show(digits[i])
        while button_a.is_pressed() :
            pass

    # Choix du deuxième nombre par la touche B
    elif button_b.is_pressed():
        j = j+1 if j < base-1 else 0
        display.show(digits[j])
        while button_b.is_pressed() :
            pass

Choix du premier nombre par la touche A :

Choix du deuxième nombre par la touche B :

Demande le résultat de la somme par la zone sensitive :

Partagez

0 Partages