Activité de découverte

PARTIE 1 — Allumer une LED sur l’anneau

Objectif

Dans cette activité, tu vas apprendre :

à contrôler une LED précise
à choisir sa couleur
à comprendre comment un programme pilote un objet réel

Programmation

Recopie ce programme dans Thonny :

from microbit import *
import neopixel

ring = neopixel.NeoPixel(pin0, 16)

ring[0] = (20, 0, 0)   # rouge
ring.show()

Puis clique sur ▶️ Exécuter.

Observe ce qu’il se passe.

ring = neopixel.NeoPixel(pin0, 16)

Cela signifie :

Le signal des LEDs est branché sur P0
Il y a 16 LEDs sur l’anneau
On crée un objet appelé ring pour contrôler l’anneau

ring[0] = (20, 0, 0)

ring → l’anneau
[0] → la LED numéro 0

⚠ Les LEDs sont numérotées de 0 à 15 (et pas de 1 à 16 !)

Donc :

ring[0] = première LED
ring[1] = deuxième LED
…
ring[15] = dernière LED

(20, 0, 0)

correspond à la couleur en RGB :

(Rouge, Vert, Bleu)

Chaque valeur peut aller de :

0 → éteint à 255 → très lumineux

ring.show()

Cette ligne dit :

👉 “Envoie les informations aux LEDs maintenant”

Sans cette ligne… rien ne s’affiche !

Petit défi

Allume en même temps :

La led n°0 en rouge
La led n°4 en vert
La led n°8 en bleu
La led n°12 en jaune

PARTIE 2 — Faire tourner la lumière

Objectif

Dans cette activité, tu vas apprendre :

à utiliser une variable
à créer une boucle infinie
à faire avancer une LED automatiquement
à comprendre comment créer un mouvement

Programmation

Recopie ce programme dans Thonny :

from microbit import *
import neopixel

ring = neopixel.NeoPixel(pin0, 16)

pos = 0   # position de la LED allumée

while True:

    # Allumer la LED actuelle en bleu
    ring[pos] = (0,0,20)
    ring.show()

    sleep(100)
    
    # Eteindre la led
    ring[pos] = (0,0,0)
    ring.show()
    
    # Passer à la LED suivante
    pos = (pos + 1) % 16

Puis clique sur ▶️ Exécuter.

Observe ce qu’il se passe.

La vitesse dépend de :

sleep(100)

Cette commande fait une pause au programme de 100 millisecondes (0,1 seconde).

Petit défi

Augmente la vitesse de rotation.
Fais en sorte que la rotation soit d’un tour par seconde.
Faire un « train » de 3 leds. Au lieu d’allumer une seule LED, on allume 3 LEDs d’affilée, et on éteint celle de derrière.
Faire une mini horloge : une led rouge parcourt l’anneau en 1 seconde, une led verte parcourt l’anneau en 16 secondes.

PARTIE 3 — Utiliser les boutons pour contrôler l’anneau

Objectif

Tu vas apprendre à :

détecter un appui sur A et B
contrôler l’animation : pause / vitesse / sens
créer un mini-jeu / défi

Programmation

Recopie ce programme dans Thonny :

from microbit import *
import neopixel

ring = neopixel.NeoPixel(pin0, 16)

pos = 0

while True:
    # Afficher la LED actuelle
    ring[pos] = (0, 0, 20)
    ring.show()

    # Si on appuie sur A, on avance
    if button_a.was_pressed():
        ring[pos] = (0, 0, 0)   # éteint l'ancienne
        ring.show()
        pos = (pos + 1) % 16    # avance

    sleep(20)

Puis clique sur ▶️ Exécuter.

Observe ce qu’il se passe quand tu appuies sur le bouton A.

if button_a.was_pressed():

Si le bouton A est appuyé alors on fait…

Petit défi

Fais en sorte que lorsque l’on appuie sur le bouton B la led recule.
En reprenant ton programme qui fait tourner une led rouge autour de l’anneau, fais en sorte que le bouton A diminue la vitesse de rotation et que le bouton B l’augmente.

PARTIE 4 — Utiliser le hasard (aléatoire)

Objectif

Dans cette activité, tu vas apprendre à :

générer un nombre au hasard
utiliser ce nombre pour choisir une LED
créer un comportement imprévisible

Beaucoup de jeux vidéo utilisent l’aléatoire pour créer du suspense 🎲.

Programmation

Recopie ce programme dans Thonny :

from microbit import *
import neopixel
import random

ring = neopixel.NeoPixel(pin0, 16)

pos = random.randint(0,15)

ring[pos] = (0,20,0)
ring.show()

Puis clique sur ▶️ Exécuter.

Observe ce qu’il se passe en réexécutant le programme.

random.randint(0, 15)

Cette commande permet de générer un nombre aléatoire entre 0 et 15.

Petit défi

Fais en sorte qu’un led aléatoire s’allume toutes les secondes.
Fais en sorte que cette led est une couleur aléatoire.

PARTIE 5 — Défi final : le jeu de réflexe (LED + bouton + hasard)

Objectif du jeu

Sur l’anneau de LEDs :

une LED verte apparaît à un endroit au hasard → c’est la cible
une LED bleue tourne autour de l’anneau

Le but du jeu est d’appuyer sur le bouton A au bon moment quand la LED bleue passe sur la LED verte.

Guide

Étape 1 — Préparer le programme

Commence par :

importer les bibliothèques nécessaires pour utiliser :
- le micro:bit
- l’anneau de LEDs
- le hasard

Ensuite :

crée une variable qui représente le nombre de LEDs de l’anneau (il y en a 16)
crée l’objet qui permettra de contrôler l’anneau RGB

from microbit import *
import neopixel
import random

# nombre de LEDs sur l'anneau
N = 16

# création de l'anneau RGB connecté sur P0
ring = neopixel.NeoPixel(pin0, N)

Étape 2 — Choisir une LED cible au hasard

Le jeu doit avoir une LED cible verte.

Pour cela :

crée une variable appelée cible
donne-lui une valeur choisie au hasard entre la première et la dernière LED

Teste ton programme en :

allumant cette LED en vert
envoyant l’information à l’anneau

Quand tu relances le programme plusieurs fois, la LED verte doit apparaître à des endroits différents.

Étape 3 — Faire tourner une LED bleue

Maintenant on ajoute une LED qui tourne autour de l’anneau.

Pour cela :

crée une variable appelée pos
cette variable représente la position de la LED bleue

Ensuite :

crée une boucle infinie
dans cette boucle :
- allume la LED bleue
- attends un petit moment
- éteins cette LED
- passe à la LED suivante

Pour passer à la LED suivante :

augmente la position de 1
utilise l’opérateur modulo (%) pour revenir à la LED 0 quand on dépasse la dernière.

Quand tu lances le programme, la LED bleue doit tourner autour de l’anneau.

Étape 4 — Afficher la cible et la LED qui tourne en même temps

Maintenant il faut voir :

la cible verte
la LED bleue qui tourne

Dans chaque tour de boucle :

éteins toutes les LEDs
allume la LED verte à la position cible
allume la LED bleue à la position pos
envoie les informations à l’anneau

Astuce :
si la LED bleue arrive exactement sur la verte, tu peux afficher une couleur différente pour montrer qu’elles sont superposées.

Étape 5 — Ajouter le bouton A

Le joueur doit appuyer sur A quand la LED bleue est sur la cible.

Dans la boucle :

détecte si le bouton A vient d’être pressé
compare la position de la LED bleue avec la position de la cible

Deux cas :

Si les positions sont les mêmes

→ le joueur a réussi.

Sinon

→ le joueur s’est trompé.

Étape 6 — Ajouter un score

Le jeu doit compter les réussites consécutives.

Pour cela :

crée une variable score
si le joueur réussit :
- augmente le score de 1
si le joueur se trompe :
- remets le score à 0

Ensuite :

affiche le score sur l’écran du micro:bit avec la commande :

display.show(score)

Étape 7 — Nouvelle cible

Après chaque tentative :

choisis une nouvelle LED cible au hasard

Le jeu recommence immédiatement.

Résultat attendu

Ton programme doit produire :

une LED verte aléatoire
une LED bleue qui tourne
un jeu de réflexe avec le bouton A
un score affiché sur l’écran