Catégorie : MICRO PYTHON

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.

---

Etape 2 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)

---

Etape 3 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

---

Etape 4 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 ?

---

Etape 5 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 

---

Etape 6 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

---

Etape 7 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

---

Etape 8 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

---

Etape 9 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 

---

Etape 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)

---

Etape 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.

---

Etape 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)