Catégorie : Robotique

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.

1. 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 ?
2. Modifier la table Ajoute les chiffres manquants ("4" et "5") dans la table all_images.
3. Tester le programme Télécharge ton programme sur la micro:bit et vérifie que les chiffres défilent bien de 1 à 5.
4. 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)

1. 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 ?
2. 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.
3. 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.
4. 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

1. 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.
2. 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.
3. Utilisation des restes : Chaque reste correspond à un chiffre hexadécimal, mais il faut les lire à l’envers à la fin.
4. 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

1. 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".
     
2. 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).
   
3. 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.
     
4. 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).
     
5. 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 :

Découvrir le code en python :

Bienvenue dans ce livret qui va te permettre de découvrir le monde
passionnant de la programmation avec le langage Python et la carte
micro:bit ! Tu vas t’amuser à apprendre les bases du codage tout en
explorant les fonctionnalités géniales de la carte micro:bit. Python est un langage de programmation puissant, mais pas compliqué une fois qu’on le comprend bien. Avec lui, tu pourras créer des jeux, contrôler des robots, afficher des messages et bien plus encore sur ta carte micro:bit.

Contrôler la carte micro:bit en python :

Dans ce livret, tu vas découvrir pas à pas comment écrire des lignes de code en Python pour contrôler ta carte micro:bit. N’aie pas peur, on va commencer par les bases, et tu verras à quel point coder peut-être amusant et créatif ! Alors, prêt à plonger dans le monde magique de la programmation avec Python et la carte micro:bit ? C’est parti !

Editeur MU Python :

MU est choisi comme éditeur pour sa simplicité d’utilisation et sa
convivialité, spécialement conçu pour les débutants en programmation.
Son interface intuitive offre une plateforme idéale pour coder en Python pour la carte micro:bit. Avec ses fonctionnalités adaptées, MU facilite l’écriture, la modification et l’exécution du code, offrant ainsi une expérience d’apprentissage agréable et efficace dans le cadre de la robotique.

---

PARTIE 01 : Découverte de la MICRO:BIT et de PYTHON

Découverte de MU

Dans MU par le bouton Mode sélectionner BBC microbit :

Puis créé un nouveau fichier

La première fonction, toute simple, de la carte micro:bit consiste à afficher un texte qui va défiler lettre par lettre sur l’écran :

from microbit import display 
display.show('Bonjour comment vas-tu ?') 

Que constates-tu après avoir téléversé le programme ?
Le texte doit défilé sur la carte micro :bit.

Tu peux simuler ton code sur le site : https://create.withcode.uk/
Copie et colle ton programme Python
Appuie ensuite sur les touches Ctrl+Entrée. Le simulateur démarre et affiche la carte micro:bit avec laquelle il est possible d’interagir.

---

PARTIE 02 : Afficher un dessin

Il est possible d’afficher des icônes sur l’écran composé d’une matrice de 5×5 LEDs en utilisant la commande display.show().

from microbit import display
display.show(Image.ANGRY)

Utilise l’icône « Vérifier » pour ton code : il te manque l’objet « Image »

from microbit import display, Image 
display.show(Image.ANGRY) 

Que constates-tu après avoir téléversé le programme ?
L’icone s’affiche sur l’écran des 25 LEDs ?

Pour connaître toutes les images possibles deux solutions :

Solution 1 :

Solution 2 :

Utilise l’icône « REPL » et dans la fenêtre ouverte frappe les indications
suivantes :

from microbit import *
dir(display)
dir(Image)

---

PARTIE 03 : Créer sa propre icône

Tu peux concevoir ta propre icône en spécifiant quelles LEDs doivent être allumées pour dessiner l’image désirée.

from microbit import display, Image
led_image = Image('00900:00900:99999:00900:00900')
display.show(led_image)

Que constates-tu après avoir téléversé le programme ?
A quoi correspond les 0 et les 9 de led_image ?
Comment modifier led_image pour avoir ton icône ?
Tu as la possibilité de contrôler l’intensité de chaque LED en ajustant la valeur de chacune sur une échelle de 1 à 9.

from microbit import display, Image
led_image = Image( '00900:00500:95959:00500:00900')
display.show(led_image)

Que constates-tu après avoir téléversé le programme ?
Vois-tu des différences d’intensité entre chaque LED ?

Documentation sur Image

---

PARTIE 04 : Faire clignoter une icône

Pour créer un effet de clignotement d’une icône, tu dois afficher cette dernière pendant une durée déterminée, puis éteindre la matrice de LEDs.

from microbit import display,Image
import time
while True:
    led_image = Image('00900:00900:99999:00900:00900')
    display.show(led_image)
    time.sleep(0.5)
    display.clear()
    time.sleep(0.5) 

Que constates-tu après avoir téléversé le programme ?
Comment peux-tu modifier pour un clignotement plus rapide ou plus lent ?

---

PARTIE 05 : Afficher un chronomètre en seconde

Afficher les aiguilles toutes les secondes.

from microbit import display,Image 
import time 
 
seconde=0 
while True: 
    if seconde==0: 
        display.show(Image.CLOCK12) 
    if seconde==1: 
        display.show(Image.CLOCK1) 
    if seconde==2: 
        display.show(Image.CLOCK2) 
    if seconde==3: 
        display.show(Image.CLOCK3)     
    if seconde==4: 
        display.show(Image.CLOCK4) 
    if seconde==5: 
        display.show(Image.CLOCK5) 
    if seconde==6: 
        display.show(Image.CLOCK6) 
    if seconde==7: 
        display.show(Image.CLOCK7) 
    if seconde==8: 
        display.show(Image.CLOCK8) 
    if seconde==9: 
        display.show(Image.CLOCK9) 
    if seconde==10: 
        display.show(Image.CLOCK10) 
    if seconde==11: 
        display.show(Image.CLOCK11) 
        seconde=-1 
    time.sleep(1) 
    seconde+=1 

---

PARTIE 06 : Animer des images et jouer une note

La carte micro:bit dispose d’un buzzer. Programme le battement d’un cœur !

from microbit import * 
import time 
import music 
# Buzzer on pin_speaker 
while True: 
    display.show(Image.HEART) 
    time.sleep(1) 
    led_image = Image('00000:09090:09990:00900:00000') 
    display.show(led_image) 
    music.pitch(200, duration=500) 

Documentation sur music

---

PARTIE 07 : Utiliser les boutons

La carte micro:bit dispose de deux boutons permettant de déclencher des actions : le bouton A à gauche de la carte, le bouton B à droite.
Programme en utilisant le bouton A :

from microbit import display, button_a, Image 
import time 
 
while True: 
    if button_a.is_pressed(): 
        led_image = Image("40004:06060:00900:06060:40004") 
        display.show(led_image) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    led_image = Image("33333:30003:30003:30003:33333") 
    display.show(led_image)

Optimise ton code :

from microbit import display, button_a, Image 
import time 
 
led_image_a = Image("40004:06060:00900:06060:40004") 
led_image = Image("33333:30003:30003:30003:33333") 
 
while True: 
    if button_a.is_pressed(): 
        display.show(led_image_a) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    display.show(led_image) 

Programme en utilisant le bouton A et le bouton B:

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

led_image_a = Image("90009:09090:00900:09090:90009") 
led_image_b = Image("99999:99999:99999:99999:99999") 
led_image = Image("33333:30003:30003:30003:33333") 

while True: 
    if button_a.is_pressed(): 
        display.show(led_image_a) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    if button_b.is_pressed(): 
        display.show(led_image_b) 
        time.sleep(0.5) 
        display.clear() 
        time.sleep(0.5) 
    display.show(led_image) 

Documentation sur les boutons

---

PARTIE 08 : Utiliser la touche sensitive

Touche la touche sensitive pour changer les LEDs.

from microbit import display, Image, pin_logo
import time
while True:
    # Détection de la zone sensible  
    if pin_logo.is_touched(): 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
        # Affichage tant que la zone sensible est touchée
        while pin_logo.is_touched():
          pass
    led_image = Image('00900:00900:99999:00900:00900') 
    display.show(led_image)

Que constates-tu après avoir téléversé le programme ?
Les LEDs changent quand tu passes ton doigt sur la zone sensitive ?

Documentation zone_sensible

---

PARTIE 09 : Utiliser la touche sensitive et les boutons

Modifie ton programme sur le battement du cœur pour augmenter ou baisser la note par les touches A et B, activer ou éteindre le son avec la zone sensitive.

from microbit import display, Image, button_a, button_b, pin_logo 
import time 
import music 
 
note = 200 
on = True 
start = time.time() 

while True:
    # Battement du coeur toutes les 1 seconde
    if time.time() - start > 1:
        start = time.time()
        display.clear()
        if on : 
            music.pitch(note, 200)
        time.sleep(0.1)
    else:  
        display.show(Image.HEART) 
              
    # Modification de la note avec la touche A  
    if button_a.is_pressed(): 
        if note > 0 : 
            note -= 10 
        while button_a.is_pressed(): 
            pass  
        on = True 
         
    # Modification de la note avec la touche B  
    if button_b.is_pressed(): 
        if note < 600 : 
            note += 10 
        while button_b.is_pressed(): 
            pass  
        on = True 
         
    # Activer ou non le battement du coeur  
    if pin_logo.is_touched(): 
 
        if on : 
            on = False 
        else: 
            on = True 
        while pin_logo.is_touched() : 
            pass 

---

PARTIE 10 : Secouer les LEDs

Secouer la carte pour allumer les LEDs.

from microbit import display, Image, accelerometer 
import time
while True: 
    if accelerometer.current_gesture() == 'shake' : 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
        time.sleep(0.1)
    led_image = Image('00900:00900:99999:00900:00900') 
    display.show(led_image)

Que constates-tu après avoir téléversé le programme ?
Tu peux essayer ces différentes possibilités :

• « shake » : secoué
• « up » : vers le haut
• « down » : vers le bas
• « face up » : écran vers le haut
• « face down » : écran vers le bas
• « left » : penché à gauche
• « right » : penché à droite
• « freefall » : chute libre
• « 3g » : 3g
• « 6g » : 6g
• « 8g » : 8g

Documentation sur l’accéléromètre

from microbit import * 
led_image = Image("33333:30003:30003:30003:33333") 
while True: 
    if accelerometer.current_gesture() == 'face up': 
        display.show(Image.ARROW_N) 
    elif accelerometer.current_gesture() == 'face down': 
        display.show(Image.ARROW_S) 
    elif accelerometer.current_gesture() == 'left': 
        display.show(Image.ARROW_W) 
    elif accelerometer.current_gesture() == 'right': 
        display.show(Image.ARROW_E) 
    else: 
        display.show(led_image)

---

PARTIE 11 : Utiliser le microphone

Claque des mains pour allumer les LEDs.

from microbit import * 
 
microphone.set_threshold(SoundEvent.LOUD, 80) 
 
while True: 
    if microphone.current_event() == SoundEvent.LOUD: 
 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
 
    led_image = Image('00900:00900:99999:00900:00900') 
    display.show(led_image)

from microbit import * 
import time 
 
while True: 
    if microphone.sound_level() > 64: 
        led_image = Image('90009:09090:00900:09090:90009') 
        display.show(led_image) 
        time.sleep(0.3) 
    else: 
        led_image = Image('00900:00900:99999:00900:00900') 
        display.show(led_image)

Que constates-tu après avoir téléversé le programme ?
Essaye d’allumer les LEDs d’un claquement de mains, elles doivent rester allumer. Puis claque des mains pour les éteindre.

---

PARTIE 12 : Jouer de la musique

Joue différentes musiques en appuyant sur les boutons A et B et sur la zone sensitive.

from microbit import button_a, button_b, pin_logo, pin_speaker 
import time 
def pitch(pin, noteFrequency, noteDuration, silence_ms=10): 
    if noteFrequency != 0: 
        microsecondsPerWave = 1e6 / noteFrequency 
        millisecondsPerCycle = 1000 / (microsecondsPerWave * 2) 
        loopTime = noteDuration * millisecondsPerCycle 
        for x in range(int(loopTime)): 
            pin.write_digital(1) 
            time.sleep(int(microsecondsPerWave)) 
            pin.write_digital(0) 
            time.sleep(int(microsecondsPerWave)) 
    else: 
        time.sleep_ms(noteDuration) 
        time.sleep_ms(silence_ms) 

def BuzzerStarWars(pin): 
    NOTES = ([293.66, 293.66, 293.66, 392.0, 622.25, 554.37, 
            523.25, 454, 932.32, 622.25, 554.37, 523.25, 
            454, 932.32, 622.25, 554.37, 523.25, 554.37, 454]) 
    DURATIONS = ([180, 180, 180, 800, 800, 180, 180, 180, 800, 
        400, 180, 180, 180, 800, 400, 180, 180, 180, 1000]) 
    SILENCE_DELAYS = ([40, 40, 40, 100, 100, 40, 40, 40, 100, 50, 
        40, 40, 40, 100, 50, 40, 40, 40, 100]) 
    for i in range(len(NOTES)): 
        pitch(pin, NOTES[i], DURATIONS[i], SILENCE_DELAYS[i]) 

def BuzzerR2D2(pin): 
    R2D2_NOTES = ([3520, 3135.96, 2637.02, 2093, 2349.32, 
        3951.07, 2793.83, 4186.01, 3520, 3135.96, 
        2637.02, 2093, 2349.32, 3951.07, 2793.83, 4186.01]) 
    for i in range(len(R2D2_NOTES)): 
        pitch(pin, R2D2_NOTES[i], 80, 20) 

def BuzzerCarribeanPirates(pin): 
    NOTES_1 = ([330, 392, 440, 440, 0, 440, 494, 523, 523, 
        0, 523, 587, 494, 494, 0, 440, 392, 440, 0]) 
    DURATIONS_1 = ([125, 125, 250, 125, 125, 125, 125, 250, 
        125, 125, 125, 125, 250, 125, 125, 125, 125, 375, 125]) 
    NOTES_2 = ([330, 392, 440, 440, 0, 440, 523, 587, 587, 0, 
        587, 659, 698, 698, 0, 659, 587, 659, 440, 0, 
        440, 494, 523, 523, 0, 587, 659, 440, 0, 440, 
        523, 494, 494, 0, 523, 440, 494, 0]) 
    DURATIONS_2 = ([125, 125, 250, 125, 125, 125, 125, 250, 125, 
        125, 125, 125, 250, 125, 125, 125, 125, 125, 
        250, 125, 125, 125, 250, 125, 125, 250, 125, 
        250, 125, 125, 125, 250, 125, 125, 125, 125, 375, 375]) 
    for j in range(2): 
        for i in range(len(NOTES_1)): 
            pitch(pin, NOTES_1[i], DURATIONS_1[i]) 
    for k in range(len(NOTES_2)): 
        pitch(pin, NOTES_2[k], DURATIONS_2[k]) 

while True: 
    if button_a.is_pressed(): 
        BuzzerStarWars(pin_speaker) 
    if button_b.is_pressed(): 
        BuzzerR2D2(pin_speaker) 
    if pin_logo.is_touched(): 
        BuzzerCarribeanPirates(pin_speaker) 

---

Etape 13 Jouer aux dés

Secoue la micro :bit pour jouer aux dés.

from microbit import * 
import random 
import music 

de_1 = Image('00000:00000:00900:00000:00000') 
de_2 = Image('00009:00000:00000:00000:90000') 
de_3 = Image('00009:00000:00900:00000:90000') 
de_4 = Image('90009:00000:00000:00000:90009') 
de_5 = Image('90009:00000:00900:00000:90009') 
de_6 = Image('90009:00000:90009:00000:90009') 
display.show('?') 
nombre = 0

while True: 
    if accelerometer.current_gesture() == 'shake' : 
        nombre = random.randint(1, 6) 
        music.pitch(440, 50) 
    if nombre == 1: 
        display.show(de_1) 
    if nombre == 2: 
        display.show(de_2) 
    if nombre == 3: 
        display.show(de_3) 
    if nombre == 4: 
        display.show(de_4) 
    if nombre == 5: 
        display.show(de_5) 
    if nombre == 6: 
        display.show(de_6) 

🚀 Mission : Détruire les navires ennemis et rester le dernier survivant !

Principe du jeu

Votre objectif ? Couler les navires adverses et être le dernier joueur encore en lice ! Chaque micro:bit représente un champ de bataille : à vous de viser juste.

Comment ça marche ?

• Un navire caché : Dès que vous allumez votre micro:bit, un navire apparaît aléatoirement sur la grille de LEDs (reconnaissable à sa lumière plus faible).
• Un missile à guider : La LED la plus brillante, c’est votre missile ! Inclinez votre micro:bit (avant/arrière, gauche/droite) pour le déplacer et viser l’ennemi.
• Prêt à tirer ?
  • Bouton A : Figez la position de votre missile pour ajuster votre tir.
  • Bouton B : FEU ! Envoyez votre missile vers les adversaires.
• Touché ! Si votre missile atteint un navire, la micro:bit de la victime joue une musique de défaite… mais attention, elle reviendra en jeu après un délai ! À vous de la neutraliser à nouveau.

💻 À vous de coder ! Pour créer ce jeu, voici les fonctionnalités clés à programmer :

1. Communication radio : Envoyez et recevez les coordonnées (ligne/colonne) des tirs entre toutes les micro:bits du jeu.
2. Contrôle du missile : Utilisez l’accéléromètre pour déplacer le missile en inclinant la carte.
3. Gestion des tirs :
   • Bouton A : Verrouillez la position du missile.
   • Bouton B : Lancez le tir et transmettez les coordonnées aux autres joueurs.
4. Position aléatoire du navire : À chaque début de partie, le navire apparaît à un endroit aléatoire.
5. Détection de collision : Si un missile touche un navire, affichez une croix et déclenchez une musique de défaite.
6. Temps de réapparition : Un navire touché réapparaît après quelques secondes : soyez prêt à recommencer !

💡 Pourquoi c’est génial ?

• Un jeu multijoueur : Affrontez vos amis en temps réel !
• De la stratégie : Mémorisez les tirs et neutralisez vos adversaires.
• Un projet complet : Codez la logique, l’affichage des LEDs, les sons et la communication entre cartes.

🛠️ Prêt à relever le défi ? Avec la micro:bit, vous allez apprendre à : ✔ Utiliser des capteurs (accéléromètre, boutons). ✔ Programmer l’affichage des LEDs et des sons. ✔ Faire communiquer plusieurs cartes entre elles.

À vos micro:bits ! Qui sera le dernier survivant ? 🎮💥

Le champ de bataille :

Ton navire : LED reconnaissable à sa lumière plus faible.

Ton missile : la LED la plus brillante

Déplace ton missile penche à droite/gauche

En avant / en arrière

Bouton A : fige le tir

Bouton B : Lance le missile

Touché

Programme en mode bloc

sous vittascience : https://fr.vittascience.com/microbit

Un exemple de programmation pour émettre les coordonnées x, y du missile et les recevoir :

Pour tester si le bouton B est relâché :

Pour gérer le roulis (droite/gauche) :

Pour gérer le tangage (avant/arrière) :

Pour gérer l’affichage de la position du missile :

Pour gérer l’affichage aléatoire du navire :

Puis dans Répéter indéfiniment :

Si touché :

Pour figer la cible avec le bouton A, avec une variable emettre :

• emettre = 0 : réglage de la cible
• emettre = 1 : cible figée

Le bouton A fige la position du tir :

Programme en python

Librairie à importer :

from microbit import *
import radio
import random
import math
import music

Pour configurer la radio :

radio.on()
radio.config(channel = 83, power = 6, length = 32, group=5)

Fonction pour émettre les coordonnées pour correspondre au programme en mode bloc :

def radio_sendValue(name, value):
    radio.send("&&&" + "int:" + "[" + name + ";" + str(value) + "]&&&")

Fonction pour recevoir les coordonnées pour correspondre au programme en mode bloc :

def radio_receiveValue():
    data = radio.receive()

    if data:
        print("receive", data)
        parseData = data[8:-4].split(';')
        return parseData[0], int(parseData[1])
    else:
        return None, None

Pour afficher une image de LEDs :

led_image = Image('00000:00000:00000:00000:00000')
display.show(led_image)

Affichage d’une LED :

 display.set_pixel(x, y, 9)
 display.set_pixel(x_cible, y_cible, 4)

pour générer un nombre aléatoire :

x_cible = random.randint(0, 4)
y_cible = random.randint(0, 4)

Affichage d’une croix :

display.show(Image.NO)

Affichage signe envoyé :

display.show(Image.YES)

Gestion des boutons A et B :

if button_a.is_pressed():
    while not (not button_a.is_pressed()):
        pass

Gestion de l’accéléromètre :

if (
   math.atan2(
       accelerometer.get_x(),
       math.sqrt(accelerometer.get_y()**2 + accelerometer.get_z()**2)
       ) * 180.0 / math.pi > 30
   ):
   x = 4

if (
   math.atan2(
       accelerometer.get_y(), -accelerometer.get_z()) *
       180.0 / math.pi > 30
   ):
   y = 4

Lancement de la musique :

music.play(music.JUMP_DOWN, loop=False)