Objectif :

Réalisation d’un programme pour gérer une calculette.

Mission :

• Utilise les boutons A ou B pour réveiller a calculette,
• Choix des nombres de 0 à 9 avec le bouton A ou B,
• Choix des opérateurs +,-,*,/,= avec le bouton A ou B,
• Calcul par le choix de l’opérateur =, afficher les opérations puis le résultat
• Un appui long permet l’arrêt la mise en veille

Etapes :

1. Affichage d’un caractère
2. Affichage des nombres et des opérateurs
3. Attendre la saisie de la touche A ou B
4. Affichage d’une liste de caractères et le choix
5. Affichage d’un chiffre avec virgule avec la notion d’un ascenseur
6. Calcul des différentes opérations
7. Choix d’un nombre puis d’un opérateur
8. Mémorisation des différentes opérations
9. Calcul

Table des matières

• Découverte des instructions à utiliser.
• Le dictionnaire en python.
• Les fonctions en Python.
• Etape 1 Affichage d’un caractère.
• Etape 2 Affichage des nombres.
• Etape 3 Attendre la saisie de la touche A ou B.
• Etape 4 Détection de la saisie du bouton A ou B.
• Etape 5 Afficher une liste de caractères et choix d’un caractère.
• Etape 6 Afficher un chiffre à virgule.
• Etape 7 Calcul des différentes opérations arithmétiques de base.
• Etape 8 Calculette choix de deux nombres et d’un opérateur.
• Etape 9 Calculette mémorisation des opérations.
• Etape 10 Affichage du résultat de l’opération.
• Etape 11 Sonoriser ta calculette.

Découverte des instructions à utiliser

#Affichage d’une LED
from pystubit.board import display
display.set_pixel(0, 0, 9)
display.set_pixel(colonne de 0 à 4, ligne de 0 à 4,intensité de la LED de 0 à 9)
INTENSITE_LED=9
display.set_pixel(0, 0, INTENSITE _LED)

Une liste de données :

En Python, une liste est un type de données qui permet de stocker une collection ordonnée d’éléments, tels que des nombres, des chaînes de caractères ou d’autres objets. Les listes sont définies en utilisant des crochets [].

ceci_est_une_liste = [0,1,2,3,4]
#pour accéder à un élément de la liste
premier_element = ceci_est_une_liste[0]

#pour lire toute la liste
for ligne in ceci_est_un_liste:
    display.set_pixel(0, ligne, 9)

Une liste de liste :

une_liste_de_leds = [0,4,2,9,5]
ligne=0

for intensite in une_liste_de_leds:  
    display.set_pixel(0, ligne, intensite)
    ligne+=1

Le dictionnaire en python

Un dictionnaire en Python est un type de données qui permet de stocker des éléments sous forme de paires clé-valeur. Contrairement à la liste, les éléments dans un dictionnaire ne sont pas stockés dans un ordre particulier, mais plutôt associés à une clé unique qui permet d’y accéder facilement.

Les dictionnaires sont définis en utilisant des accolades {} et des paires clé-valeur séparées par des virgules. Par exemple, voici comment vous pouvez créer un dictionnaire pour stocker des informations :

from microbit import display

allume = {"OUI" :9,"NON" :0}

for colonne in range(5):
    for ligne in range(5):
        display.set_pixel(colonne, ligne, allume["OUI"])

Les fonctions en Python

Déclaration de la fonction :

Commence par déclarer la fonction en utilisant le mot-clé def, suivi du nom de la fonction et des parenthèses qui contiennent éventuellement des paramètres d’entrée. Par exemple :

def ma_fonction(parametre1, parametre2):
    # Addition de deux nombres
    # En paramètre deux nombres
    # Retourne la somme de deux nombres (optionnel)
    resultat = parametre1 + parametre2
    return resultat

nombre1=5
nombre2=2

print(nombre1,"+",nombre2,"=",ma_fonction(nombre1,nombre2))

Etape 1 Affichage d’un caractère

#Bibliothèques à importer
from microbit import display

t_zero = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 9, 9, 0],
    ]

# Affichage d’un caractère en utilisant le tableau de LEDs
def affichage(caractere):
    num_ligne = 0
    # Affichage des lignes
    for ligne in caractere:
        num_colonne = 0
        # Affichage des colonnes
        for led in ligne:
            display.set_pixel(num_colonne, num_ligne, led)
            num_colonne += 1
        num_ligne += 1

affichage(t_zero)

Flasher pour tester puis bouton reset pour lancer

from microbit import display

#Tableaux pour afficher les nombres de 0 à 9
t_zero = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 9, 9, 0],
    ]

t_un = [
    [0, 0, 9, 0, 0],
    [0, 9, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 9, 9, 0],
    ]

t_deux = [
    [0, 9, 9, 0, 0],
    [9, 0, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 9, 9, 9, 0],
    ]

t_trois = [
    [0, 9, 9, 0, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 0, 0],

]

t_quatre = [
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 9, 9, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    ]

t_cinq = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 0, 0],
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 0, 0],
]

t_six = [
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 9, 9, 0, 0],
    [9, 0, 0, 9, 0],
    [0, 9, 9, 0, 0],
    ]

t_sept = [
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    ]

t_huit = [
    [0, 0, 9, 0, 0],
    [0, 9, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 9, 0],
    [0, 0, 9, 0, 0],
    ]

t_neuf = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 0, 0],
    ]

# Tableaux pour afficher les opérateurs =,+,-,/,*

t_egal = [
    [0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 0, 0, 0],
    ]

t_plus = [
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    ]

t_moins = [
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    ]

t_div = [
    [0, 0, 0, 0, 9],
    [0, 0, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 0, 0, 0, 0],
    ]

t_multiple = [
    [9, 0, 0, 0, 9],
    [0, 9, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 9, 0],
    [9, 0, 0, 0, 9],
    ]

# Tableaux pour afficher un séparateur

t_point = [
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 9, 9, 9, 0],
    [0, 9, 9, 9, 0],
    [0, 9, 9, 9, 0],
]  

# Affichage d’un caractère

def affichage(caractere):
    num_ligne = 0
    for ligne in caractere:
        num_colonne = 0
        for led in ligne:
            display.set_pixel(num_colonne, num_ligne, led)
            num_colonne += 1
        num_ligne += 1

# Test pour afficher un caractère

affichage(t_huit)

Flasher pour tester puis bouton reset pour lancer

Peux-tu répondre à ce QCM sur la boucle FOR et les tableaux :

Quelle est la sortie du code suivant ?

tableau = [2, 4, 6, 8, 10]

for i in tableau:
    print(i)

• A) 0 1 2 3 4
• B) 2 4 6 8 10
• C) 1 2 3 4 5
• D) 0 2 4 6 8

Quelle est la sortie du code suivant ?

tableau = [3, 6, 9, 12, 15]

for i in range(len(tableau)):

    print(tableau[i])

• A) 0 1 2 3 4
• B) 3 6 9 12 15
• C) 1 2 3 4 5
• D) 0 3 6 9 12

Comment parcourir un tableau en utilisant une boucle for et l’index du tableau ?

A)

tableau = [5, 10, 15, 20]
for i in tableau:
    print(tableau[i])

B)

tableau = [5, 10, 15, 20]
for i in range(len(tableau)):
    print(tableau[i])

C)

tableau = [5, 10, 15, 20]
for i in range(tableau):
    print(tableau[i])

D)

tableau = [5, 10, 15, 20]
for i in tableau:
    print(i)

Quel est le résultat de ce code ?

tableau = [1, 2, 3, 4, 5]
total = 0

for i in tableau:
    total += i

print(total)

Comment ajouter tous les éléments d’un tableau en utilisant une boucle for ?

A)

tableau = [1, 2, 3, 4, 5]
total = 0
for i in tableau:
    total += tableau[i]
print(total)

B)

tableau = [1, 2, 3, 4, 5]
total = 0
for i in range(len(tableau)):
    total += tableau[i]
print(total)

C)

tableau = [1, 2, 3, 4, 5]
total = 0
for i in tableau:
    total += i
print(total)

D)

tableau = [1, 2, 3, 4, 5]
total = 0
for i in range(tableau):
    total += i
print(total)

Etape 2 Affichage des nombres

#Tableau de tous les nombres# Tableau de la liste des chiffres de 0 à 9

chiffres = {
    0: t_zero,
    1: t_un,
    2: t_deux,
    3: t_trois,
    4: t_quatre,
    5: t_cinq,
    6: t_six,
    7: t_sept,
    8: t_huit,
    9: t_neuf,
    }

# Tableau de tous les opérateurs

operateurs = {"=": t_egal, "+": t_plus, "-": t_moins, "*": t_multiple, "/": t_div}

#Test pour afficher un nombre
affichage(chiffres[3])

Flasher pour tester puis bouton reset pour lancer

Peux-tu répondre à ce QCM sur l’utilisation des dictionnaires Python :

Quelle est la sortie du code suivant ?

dictionnaire = {"a": 1, "b": 2, "c": 3}
print(dictionnaire["a"])

• A) « a »
• B) 1
• C) « b »
• D) 2

Comment parcourir un dictionnaire en utilisant une boucle for ?

A)

dictionnaire = {"a": 1, "b": 2, "c": 3}
for cle in dictionnaire:
    print(cle, dictionnaire[cle])

B)

dictionnaire = {"a": 1, "b": 2, "c": 3}
for cle, valeur in dictionnaire.items():
    print(cle, valeur)

C)

dictionnaire = {"a": 1, "b": 2, "c": 3}
for cle in dictionnaire.keys():
    print(cle, dictionnaire[cle])

D) Toutes les réponses précédentes sont correctes

Etape 3 Attendre la saisie de la touche A ou B

Attente de l’appui du bouton A ou bouton B

# Bibliothèques à importer
from microbit import display, button_a, button_b
import time

#Test pour attendre l’appui du bouton A ou B ou time out
def attendre_boutonA_ou_boutonB(delai_attente = 0):
    start = time.ticks_ms()

    # Attente appui sur le bouton A ou bouton B ou au bout d'un time out
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           ((delai_attente == 0) or ((time.ticks_ms()-start) < delai_attente *1000))):
        pass

    while button_a.is_pressed() or button_b.is_pressed():
        pass

affichage(chiffres[3])
attendre_boutonA_ou_boutonB(0)

affichage(chiffres[4])
attendre_boutonA_ou_boutonB(2)

affichage(chiffres[5])
attendre_boutonA_ou_boutonB(delai_attente = 2)

display.clear()

Flasher pour tester puis bouton reset pour lancer

Peux-tu répondre à ce QCM sur l’appel des fonctions Python :

Quelle est la sortie du code suivant ?

def fonction(a, b):
    return a + b
print(fonction(1, 2))

• A) 1
• B) 2
• C) 3
• D) Erreur

Comment définir une fonction avec un paramètre par défaut ? A)

def fonction(a = 1):
    return a

B)

def fonction(a):
    a = 1
    return a

C)

def fonction():
    a = 1
    return a

D) Toutes les réponses précédentes sont correctes

Comment appeler une fonction avec un argument nommé ?

A)

def fonction(a, b):
    return a + b
print(fonction(a = 1, b = 2))

B)

def fonction(a, b):
    return a + b
print(fonction(1, b = 2))

C)

def fonction(a, b):
    return a + b
print(fonction(a = 1, 2))

D) Toutes les réponses précédentes sont correctes

Comment définir une fonction avec un nombre variable d’arguments ?

A)

def fonction(*args):
    return args

B)

def fonction(args):
    return args

C)

def fonction(**args):
    return args

D) Toutes les réponses précédentes sont correctes

Etape 4 Détection de la saisie du bouton A ou B

Détection du bouton appuyé ou sur un délai d’attente

def attendre_boutonA_ou_boutonB(delai_attente = 0):

    button = "o"
    start = time.ticks_ms()

     # Attente appui sur le bouton A ou bouton B ou au bout d'un time out
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           ((delai_attente == 0) or ((time.ticks_ms()-start) < delai_attente *1000))):
        pass

    if button_a.is_pressed():
        button = "a"

    if button_b.is_pressed():
        button = "b"

    while button_a.is_pressed() or button_b.is_pressed():
        pass

    return button

while True:
    # Test pour afficher un caractère
    affichage(chiffres[3])
    print(attendre_boutonA_ou_boutonB(2))
    display.clear()

Flasher pour tester puis bouton reset pour lancer

Vérifier que vous avez en retour de la fonction dans la fenêtre REPL :

• a après l’appui du bouton A
• b après l’appui du bouton B
• après une attente de plus de 2 secondes

Détection d’un appui long sur la touche A ou B

def attendre_boutonA_ou_boutonB(delai_attente = 0, delai_appui_long = 1500):

    button = "o"
    start = time.ticks_ms()
    start_button = 0

     # Attente appui sur le bouton A ou bouton B ou au bout d'un time out
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           ((delai_attente == 0) or ((time.ticks_ms()-start) < delai_attente *1000))):
        pass

    if button_a.is_pressed():
        button = "a"
        start_button = time.ticks_ms()

    if button_b.is_pressed():
        button = "b"
        start_button = time.ticks_ms()

    while button_a.is_pressed() or button_b.is_pressed():
        pass

    if (start_button > 0) and ((time.ticks_ms()-start_button) > delai_appui_long):
        button = button + "l"
    return button

while True:

    # Test pour afficher un caractère
    affichage(chiffres[3])
    print(attendre_boutonA_ou_boutonB(2))
    display.clear()

Flasher pour tester puis bouton reset pour lancer

Vérifier que vous avez en retour de la fonction dans la fenêtre REPL :

• a après l’appui du bouton A
• b après l’appui du bouton B
• après une attente de plus de 2secondes
• al après l’appui long sur le bouton A
• bl après l’appui long sur le bouton B

Test de tous les nombres

nbr=0
while True:
    # Test pour afficher un caractère
    affichage(chiffres[nbr])
    print(attendre_boutonA_ou_boutonB(2))
    nbr += 1
    if nbr >= len(chiffres):
        nbr = 0

Flasher pour tester puis bouton reset pour lancer

En appuyant sur les boutons A ou B tu dois faire défiler les nombres de 0 à 9

Test de tous les opérateurs

nbr=0

# Mettre le dictionnaire des opérateurs en liste
operateurs_list = list(operateurs.items())

while True:
    # Test pour afficher un caractère
    # Utiliser la clé du dictionnaire pour afficher l'opérateur
    affichage(operateurs[operateurs_list[nbr][0]])
    print(attendre_boutonA_ou_boutonB(2))
    nbr += 1
    if nbr >= len(operateurs):
        nbr = 0

Flasher pour tester puis bouton reset pour lancer

En appuyant sur les boutons A ou B tu dois faire défiler les opérateurs de 0 à 9

L’utilisation de fonctions dans un code Python permet d’améliorer la visibilité et la maintenance du code. Voici quelques raisons pour lesquelles cela est vrai :

1. Structuration du code : Les fonctions permettent de diviser le code en blocs logiques et fonctionnels, ce qui facilite la compréhension du code par les autres développeurs ou par soi-même plus tard. En regroupant les instructions qui effectuent une tâche spécifique dans une fonction, on peut rendre le code plus facile à lire et à comprendre.

• Réutilisation du code : Les fonctions peuvent être réutilisées dans différentes parties du code, ce qui évite de dupliquer des instructions similaires à plusieurs endroits. Cela permet également de simplifier le code et de réduire les erreurs de copier-coller.

• Facilité de maintenance : Les fonctions permettent de modifier le code plus facilement. Si une partie du code doit être modifiée, il suffit de modifier la fonction correspondante plutôt que de modifier plusieurs lignes de code dans différentes parties du programme. Cela permet de gagner du temps et de réduire les risques d’introduire de nouvelles erreurs.

• Amélioration de la visibilité : Les fonctions peuvent être nommées de manière à décrire leur fonctionnalité, ce qui facilite la compréhension du code. En utilisant des noms de fonctions significatifs, on peut rendre le code plus facile à comprendre pour les autres développeurs ou pour soi-même plus tard.

• Réduction des erreurs : Les fonctions permettent de réduire les erreurs en limitant la portée des variables et en évitant les conflits de noms. En utilisant des variables locales à l’intérieur d’une fonction, on peut éviter les conflits de noms avec des variables globales ou des variables d’autres fonctions.

En résumé, l’utilisation de fonctions permet de structurer le code, de faciliter la réutilisation et la maintenance du code, d’améliorer la visibilité et de réduire les erreurs. Il est donc recommandé d’utiliser des fonctions dans un code Python pour améliorer sa qualité et sa lisibilité.

Etape 5 Afficher une liste de caractères et choix d’un caractère

"""
Choix des chiffres ou des opérateurs
les boutons A et B pour faire défiler les caractères
Appui long sur A ou B pour valider le caractère
"""

def choix_caractere(caracteres, item=0, delai_attente=0, delai_appui_long=1500):
    button = ""
    caractereres_keys = list(caracteres.keys())
    try:
        item = caractereres_keys.index(item)
    except ValueError:
        item=0

    while True:
        if caractereres_keys[item] in caracteres:
            # Affichage du caratère
            affichage(caracteres[caractereres_keys[item]])
            # Attente bouton A ou B
            button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
            # Défilement des caratères
            if button == "a":
                item -= 1
            if button == "b":
                item += 1
            # Appui long sur A ou B
            if button == "al" or button == "bl":
                return caractereres_keys[item]
            # Délai d'attente dépassé
            if button == "o":
                return None
        if item >= len(caractereres_keys):
            item = 0
        if item < 0:
            item = len(caractereres_keys) - 1

#Tester le défilement des chiffres               
while True:
    print(choix_caractere(chiffres, 0, 5, 1000))

#Tester le défilement des opérateurs
while True:
    print(choix_caractere(operateurs, 0, 5, 1000))

Flasher pour tester puis bouton reset pour lancer

QCM sur les différentes possibilités pour arrêter une boucle infinie while True: utilisée dans une fonction en Python :

Comment arrêter une boucle infinie en utilisant les instructions ?

• A) En utilisant l’instruction continue
• B) En utilisant l’instruction return
• C) En utilisant l’instruction pass
• D) En utilisant l’instruction break

Comment arrêter une boucle infinie en utilisant une variable de contrôle ?

• A) En utilisant l’instruction continue
• B) En utilisant l’instruction break
• C) En utilisant une variable de contrôle
• D) En utilisant l’instruction pass

Quelle instruction permet de sauter une itération dans une boucle ?

• A) L’instruction break
• B) L’instruction return
• C) L’instruction pass
• D) L’instruction continue

# Affichage d'un ascenceur pour les nombres de plusieurs chiffres
def barre_ascenceur(maxi, ascenceur):
    if maxi > 5:
        maxi = 5

    if ascenceur >= maxi:
        ascenceur = maxi - 1

    # Effacement 5éme colonne
    for ligne in range(5):
        display.set_pixel(4, ligne, 0)

    # Affichage de l'ascenceur
    display.set_pixel(4, ascenceur, 5)

#Affichage d’un nombre avec une virgule
# Affichage d’un nombre avec une virgule
def affichage_nombre(nombre, delai_attente=0, delai_appui_long=1500):
    # Convertir le nombre en une chaine de caractère
    nombreString = str(nombre)
    grandeur = len(nombreString)
    ascenceur = 0
    button = ""

    # Affichage du nombre jusqu'à appui long ou hors délai d'attente
    while (not (button == "al") and
           not (button == "bl") and
           not (button == "o")):

        # Affichage d'un caractère du nombre et de l'ascenceur
        if nombreString[ascenceur] == ".":
            affichage(t_point)
        elif nombreString[ascenceur] == "-":
            affichage(t_moins)
        else:
            affichage(chiffres[int(nombreString[ascenceur])])

        barre_ascenceur(grandeur, ascenceur)
        # Attente récation de l'utilisateur
        button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
        if button == "a":
            ascenceur -= 1
        if button == "b":
            ascenceur += 1
        if ascenceur >= grandeur:
            ascenceur = 0
        if ascenceur < 0 :
            ascenceur = grandeur-1
    return button

# Tester un nombre avec deux chiffres, défilement de l’ascenseur avec les bouton A ou B
# Validation par un appui long               
while True:
    affichage_nombre(-123456.4,0)
    affichage_nombre(-987)
    affichage_nombre(-55.1234)

Etape 6 Afficher un chiffre à virgule

Flasher pour tester puis bouton reset pour lancer

Afficher un nombre avec plusieurs chiffres, avec éventuellement un signe moins, une virgule :

• Faire défiler le nombre avec les touches A et B
• Valider le nombre par un appui long sur A ou B
• Vérifier la présence du signe moins – et la présence de la virgule .

Etape 7 Calcul des différentes opérations arithmétiques de base

# Calcul avec deux nombres
def calcul(nombre1, operateur="=", nombre2=0):
    resultat = 0
    if operateur == "=":
        resultat = nombre1
    if operateur == "+":
        resultat = nombre1 + nombre2
    if operateur == "-":
        resultat = nombre1 - nombre2
    if operateur == "*":
        resultat = nombre1 * nombre2
    if operateur == "/":
        if nombre2 > 0:
            resultat = nombre1 / nombre2
    return resultat

while True:
    # Initialiser
    resultat = calcul(2)
    affichage_nombre(resultat)
    # Additionner
    resultat = calcul(resultat, "+", 4)
    affichage_nombre(resultat)
    # Soustraire
    resultat = calcul(resultat, "-", 4)
    affichage_nombre(resultat)
    # Multiplier
    resultat = calcul(resultat, "*", 2)
    affichage_nombre(resultat)
    # Diviser
    resultat = calcul(resultat, "/", 2)
    affichage_nombre(resultat)
    # Division par zéro impossible
    resultat = calcul(resultat, "/", 0)
    affichage_nombre(resultat)

Flasher pour tester puis bouton reset pour lancer

Vérifier que le calcul est correct après chaque opération :

• Faire défiler le résultat par les touches A et B
• Valider le résultat par un appui long sur A ou B
  

Etape 8 Calculette choix de deux nombres et d’un opérateur

operateur = "+"
while True:
    nombre1 = choix_caractere(chiffres)
    operateur = choix_caractere(operateurs, operateur)
    nombre2 = choix_caractere(chiffres)
    resultat = calcul(nombre1, operateur, nombre2)
    affichage_nombre(resultat)

Flasher pour tester puis bouton reset pour lancer

Les opérateurs +, -, * et / sont respectivement appelés :

• L’opérateur d’addition (+)
• L’opérateur de soustraction (-)
• L’opérateur de multiplication (*)
• L’opérateur de division (/)

Ces opérateurs sont utilisés pour effectuer des opérations arithmétiques de base sur des nombres en Python. Par exemple :

# Addition
5 + 3  # Résultat : 8

# Soustraction
5 - 3  # Résultat : 2

# Multiplication
5 * 3  # Résultat : 15

# Division
5 / 3  # Résultat : 1.6666666666666667

Il est important de noter que l’opérateur de division (/) renvoie un résultat sous forme de nombre à virgule flottante, même si les nombres utilisés sont des entiers. Pour obtenir un résultat sous forme d’entier, il est possible d’utiliser l’opérateur de division entière (//) :

# Division entière
5 // 3  # Résultat : 1

L’opérateur de division entière renvoie le quotient entier de la division, en arrondissant vers le bas. Le reste de la division peut être obtenu en utilisant l’opérateur de modulo (%) :

# Modulo
5 % 3  # Résultat : 2

L’opérateur de modulo renvoie le reste de la division entière.

Etape 9 Calculette mémorisation des opérations

En Python, une liste est une structure de données qui permet de stocker une collection ordonnée d’éléments. Les éléments d’une liste peuvent être de n’importe quel type (entiers, chaînes de caractères, listes, etc.).

Pour ajouter des éléments à une liste en Python, on peut utiliser la méthode append(). La méthode append() ajoute un élément à la fin de la liste. Voici un exemple :

# Création d'une liste vide
ma_liste = []

# Ajout d'éléments à la liste
ma_liste.append(1)
ma_liste.append(2)
ma_liste.append(3)

# Affichage de la liste
print(ma_liste)  # Résultat : [1, 2, 3]

Dans cet exemple, on crée une liste vide ma_liste. On ajoute ensuite les éléments 1, 2 et 3 à la liste en utilisant la méthode append(). Enfin, on affiche la liste à l’aide de la fonction print(). Le résultat affiché est [1, 2, 3].

Il est également possible d’ajouter plusieurs éléments à une liste en utilisant la méthode extend(). La méthode extend() prend une liste en argument et ajoute tous les éléments de cette liste à la fin de la liste existante. Voici un exemple :

# Création d'une liste
ma_liste = [1, 2, 3]

# Ajout de plusieurs éléments à la liste
ma_liste.extend([4, 5, 6])

# Affichage de la liste
print(ma_liste)  # Résultat : [1, 2, 3, 4, 5, 6]

Dans cet exemple, on crée une liste ma_liste contenant les éléments 1, 2 et 3. On ajoute ensuite les éléments 4, 5 et 6 à la liste en utilisant la méthode extend(). Enfin, on affiche la liste à l’aide de la fonction print(). Le résultat affiché est [1, 2, 3, 4, 5, 6].

def saisie_operation():
    operation = []
    item = 0
    retour = 0

    operateur = "+"
    while ((retour is not None) and
            (retour != "=")):
        item += 1
        resultat = None
        # Saisie de l'opération nombre opérateur nombre ... jusqu'au égal =
        if item % 2 == 0:
            retour = choix_caractere(operateurs, operateur,
                                     delai_attente=60,
                                     delai_appui_long=700)

            if retour :
                operateur = retour
        else:
            retour = choix_caractere(chiffres,
                                     delai_attente=60,
                                     delai_appui_long=700)

        if retour :
            operation.append(retour)

    if retour :
        return operation
    else:      
        return None

while True:
    # Saisie de l’opération   
    print(saisie_operation())

Flasher pour tester puis bouton reset pour lancer et visualise le résultat dans REPL

1. Fait le choix des nombres par les touches A et B puis valide le nombre par un appui long par les touches A ou B
2. Puis fait le choix de l’opérateur de ton opération par les touches A et B puis valide par un appui long par les touches A ou B
3. Valide ton calcul par le choix de l’opérateur « = » par un appui long sur A ou B
4. Vérifie ton calcul dans la console REPL

Etape 10 Affichage du résultat de l’opération

def affichage_calcul(operation):
    resultat = 0
    if operation :
        item = 0
        for operande in operation:
            item += 1
            if item % 2 == 0:
                operateur = operande
                affichage(operateurs[operateur])
                attendre_boutonA_ou_boutonB(1)
            else:
                affichage(chiffres[operande])
                attendre_boutonA_ou_boutonB(1)
                # Calcul de l'opération
                if item == 1 :
                    resultat = calcul(operande)
                else:
                    resultat = calcul(resultat, operateur, operande)
    return resultat

button = ""   
while True:
    # Saisie de l'opération
    operation = saisie_operation()
    # Affichage de l'opération et calcul de l'opération
    if operation :
        # Affichage et calcul de l'opération
        resultat = affichage_calcul(operation)
        # Affichage du résultat
        button = affichage_nombre(resultat,
                         delai_attente=60,
                         delai_appui_long=700)

    if operation is None or button == "o" :
        # Mise en veille
        display.clear()
        attendre_boutonA_ou_boutonB()

Flasher pour tester puis bouton reset pour lancer

QCM sur les différentes possibilités d’ajouter des éléments dans une liste en Python :

Comment ajouter un élément à la fin d’une liste en Python ?

• A) En utilisant la méthode add() 
• B) En utilisant la méthode insert() 
• C) En utilisant la méthode append() 
• D) En utilisant la méthode extend()

Comment ajouter plusieurs éléments à la fin d’une liste en Python ?

• A) En utilisant la méthode add() 
• B) En utilisant la méthode insert() 
• C) En utilisant la méthode append() 
• D) En utilisant la méthode extend()

Comment ajouter un élément à une position spécifique dans une liste en Python ?

• A) En utilisant la méthode add() 
• B) En utilisant la méthode insert() 
• C) En utilisant la méthode append() 
• D) En utilisant la méthode extend()

Comment ajouter une liste à une autre liste en Python ?

• A) En utilisant la méthode add() 
• B) En utilisant la méthode insert() 
• C) En utilisant la méthode append() 
• D) En utilisant la méthode extend()

Comment ajouter un élément au début d’une liste en Python ?

• A) En utilisant la méthode add() avec l’index 0.
• B) En utilisant la méthode insert() avec l’index 0.
• C) En utilisant la méthode append() avec l’index 0.
• D) En utilisant la méthode extend()avec l’index 0.

Exemple pour comprendre :

liste1= [1,2,3,4]

liste2= [10,11,12,13]

liste1.append(6)

liste1.extend([7,8,9])

liste1.insert(4,5)

liste1.extend(liste2)

liste1.insert(0,0)

print(liste1)

Etape 11 Sonoriser ta calculette

La sonorisation des logiciels est un domaine de recherche qui vise à améliorer l’interaction entre l’utilisateur et le logiciel en utilisant des sons. Les sons peuvent être utilisés pour fournir des commentaires à l’utilisateur sur ses actions, pour signaler des événements importants ou pour renforcer la compréhension de l’interface utilisateur.

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

def attendre_boutonA_ou_boutonB(delai_attente=0, delai_appui_long=1500):
    button = "o"
    start = time.ticks_ms()
    start_button = 0
    # Attente appui sur le bouton A ou bouton B ou au bout d'un time out
    while (
        not (button_a.is_pressed())
        and not (button_b.is_pressed())
        and ((delai_attente == 0) or ((time.ticks_ms() - start) < delai_attente * 1000))
    ):
        pass

    if button_a.is_pressed():
        button = "a"
        start_button = time.ticks_ms()

    if button_b.is_pressed():
        button = "b"
        start_button = time.ticks_ms()

    premierefois = True

    while button_a.is_pressed() or button_b.is_pressed():
        if ((time.ticks_ms() - start_button) > delai_appui_long):
            music.pitch(200, duration=40)
        else:
            if premierefois:
                music.pitch(500, duration=20)
                premierefois = False

    if (start_button > 0) and ((time.ticks_ms() - start_button) > delai_appui_long):
        button = button + "l"
        return button

    return button

Flasher pour tester puis bouton reset pour lancer

Voici quelques raisons pour lesquelles la sonorisation des logiciels peut être importante pour améliorer l’utilisation par l’humain des logiciels :

1. Fournir des commentaires auditifs : Les sons peuvent être utilisés pour fournir des commentaires auditifs à l’utilisateur sur ses actions. Par exemple pour confirmer l’appui sur un bouton.
2. Renforcer la compréhension de l’interface utilisateur : Les sons peuvent être utilisés pour renforcer la compréhension de l’interface utilisateur en fournissant des indices auditifs sur la fonctionnalité des différents éléments de l’interface. Par exemple lors de la confirmation d’un appui long sur un bouton.
3. Signaler des événements importants : Les sons peuvent être utilisés pour signaler des événements importants dans le logiciel. Par exemple sur une erreur de saisie, indique par exemple l’erreur de la division par zéro.
4. Améliorer l’accessibilité : Les sons peuvent être utilisés pour améliorer l’accessibilité des logiciels pour les personnes malvoyantes ou non voyantes. Les sons peuvent être utilisés pour fournir des commentaires auditifs sur les actions de l’utilisateur, pour décrire les éléments de l’interface utilisateur et pour signaler des événements importants. Les sons peuvent également être utilisés pour fournir une alternative auditive aux informations visuelles. Essaye de rendre la calculette utilisable par une personne non voyante ?

En résumé, la sonorisation des logiciels peut aider à améliorer l’interaction entre l’utilisateur et le logiciel en fournissant des commentaires auditifs, en renforçant la compréhension de l’interface utilisateur, en signalant des événements importants et en améliorant l’accessibilité. Les sons peuvent être utilisés pour fournir des informations supplémentaires à l’utilisateur, pour renforcer la compréhension de l’interface utilisateur et pour améliorer l’expérience utilisateur globale.

# Bibliothèques à importer
from microbit import display, button_a, button_b
import time

t_zero = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 9, 9, 0]]

t_un = [
    [0, 0, 9, 0, 0],
    [0, 9, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 9, 9, 0]]

t_deux = [
    [0, 9, 9, 0, 0],
    [9, 0, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 9, 9, 9, 0]]

t_trois = [
    [0, 9, 9, 0, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 0, 0]]

t_quatre = [
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 9, 9, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0]]

t_cinq = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 0, 0],
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 0, 0]]

t_six = [
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 9, 9, 0, 0],
    [9, 0, 0, 9, 0],
    [0, 9, 9, 0, 0]]

t_sept = [
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0]]

t_huit = [
    [0, 0, 9, 0, 0],
    [0, 9, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 9, 0],
    [0, 0, 9, 0, 0]]

t_neuf = [
    [0, 9, 9, 9, 0],
    [0, 9, 0, 9, 0],
    [0, 9, 9, 9, 0],
    [0, 0, 0, 9, 0],
    [0, 9, 9, 0, 0]]

# Tableaux pour afficher les opérateurs =,+,-,/,*
t_egal = [
    [0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 0, 0, 0]]

t_plus = [
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 9, 0, 0],
    [0, 0, 9, 0, 0]]

t_moins = [
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [9, 9, 9, 9, 9],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]]

t_div = [
    [0, 0, 0, 0, 9],
    [0, 0, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 0, 0],
    [9, 0, 0, 0, 0]]

t_multiple = [
    [9, 0, 0, 0, 9],
    [0, 9, 0, 9, 0],
    [0, 0, 9, 0, 0],
    [0, 9, 0, 9, 0],
    [9, 0, 0, 0, 9]]

# Tableaux pour afficher un séparateur
t_point = [
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 9, 9, 9, 0],
    [0, 9, 9, 9, 0],
    [0, 9, 9, 9, 0]]

# Tableau de tous les nombres# Tableau de la liste des chiffres de 0 à 9
chiffres = {
    0: t_zero,
    1: t_un,
    2: t_deux,
    3: t_trois,
    4: t_quatre,
    5: t_cinq,
    6: t_six,
    7: t_sept,
    8: t_huit,
    9: t_neuf,
    }

# Tableau de tous les opérateurs
operateurs = {"=": t_egal, "+": t_plus, "-": t_moins, "*": t_multiple, "/": t_div}

# Affichage d’un caractère en utilisant le tableau de LEDs
def affichage(caractere):
    num_ligne = 0
    # Affichage des lignes
    for ligne in caractere:
        num_colonne = 0
        # Affichage des colonnes
        for led in ligne:
            display.set_pixel(num_colonne, num_ligne, led)
            num_colonne += 1
        num_ligne += 1

# Test pour attendre l’appui du bouton A ou B ou time out
def attendre_boutonA_ou_boutonB(delai_attente=0,
        delai_appui_long=1500):
    button = "o"
    start = time.ticks_ms()
    start_button = 0

    # Attente appui sur le bouton A ou bouton B ou au bout d'un time out
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           ((delai_attente == 0) or
           ((time.ticks_ms() - start) < delai_attente * 1000))):
        pass

    if button_a.is_pressed():
        button = "a"
        start_button = time.ticks_ms()

    if button_b.is_pressed():
        button = "b"
        start_button = time.ticks_ms()

    while button_a.is_pressed() or button_b.is_pressed():
        pass

    if (start_button > 0) and ((time.ticks_ms()-start_button) > delai_appui_long):
        button = button + "l"

    return button

"""
Choix des chiffres ou des opérateurs
les boutons A et B pour faire défiler les caractères
Appui long sur A ou B pour valider le caractère
"""

def choix_caractere(caracteres,
        item=0,
        delai_attente=0,
        delai_appui_long=1500):

    button = ""
    caractereres_keys = list(caracteres.keys())
    try:
        item = caractereres_keys.index(item)
    except ValueError:
        item = 0

    while True:
        if caractereres_keys[item] in caracteres:
            # Affichage du caratère
            affichage(caracteres[caractereres_keys[item]])
            # Attente bouton A ou B
            button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
            # Défilement des caratères
            if button == "a":
                item -= 1
            if button == "b":
                item += 1
            # Appui long sur A ou B
            if button == "al" or button == "bl":
                return caractereres_keys[item]
            # Délai d'attente dépassé
            if button == "o":
                return None

        if item >= len(caractereres_keys):
            item = 0
        if item < 0:
            item = len(caractereres_keys) - 1

# Affichage d'un ascenceur pour les nombres de plusieurs chiffres
def barre_ascenceur(maxi, ascenceur):
    if maxi > 5:
        maxi = 5

    if ascenceur >= maxi:
        ascenceur = maxi - 1

    # Effacement 5éme colonne
    for ligne in range(5):
        display.set_pixel(4, ligne, 0)

    # Affichage de l'ascenceur
    display.set_pixel(4, ascenceur, 5)

# Affichage d’un nombre avec une virgule
def affichage_nombre(nombre,
    delai_attente=0,
    delai_appui_long=1500):

    # Convertir le nombre en une chaine de caractère
    nombreString = str(nombre)
    grandeur = len(nombreString)
    ascenceur = 0
    button = ""

    # Affichage du nombre jusqu'à appui long ou hors délai d'attente
    while (not (button == "al") and
           not (button == "bl") and
           not (button == "o")):

        # Affichage d'un caractère du nombre et de l'ascenceur
        if nombreString[ascenceur] == ".":
            affichage(t_point)
        elif nombreString[ascenceur] == "-":
            affichage(t_moins)
        else:
            affichage(chiffres[int(nombreString[ascenceur])])

        barre_ascenceur(grandeur, ascenceur)

        # Attente récation de l'utilisateur
        button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
        if button == "a":
            ascenceur -= 1
        if button == "b":
            ascenceur += 1
        if ascenceur >= grandeur:
            ascenceur = 0
        if ascenceur < 0 :
            ascenceur = grandeur-1

    return button

# Calcul avec deux nombres
def calcul(nombre1, operateur="=", nombre2=0):

    resultat = 0
    if operateur == "=":
        resultat = nombre1

    if operateur == "+":
        resultat = nombre1 + nombre2

    if operateur == "-":
        resultat = nombre1 - nombre2

    if operateur == "*":
        resultat = nombre1 * nombre2

    if operateur == "/":
        if nombre2 > 0:
            resultat = nombre1 / nombre2

    return resultat

def saisie_operation():
    operation = []
    item = 0
    retour = 0
    operateur = "+"
    while ((retour is not None) and
            (retour != "=")):
        item += 1
        resultat = None

        # Saisie de l'opération nombre opérateur nombre ... jusqu'au égal =
        if item % 2 == 0:
            retour = choix_caractere(operateurs, operateur,
                                     delai_attente=60,
                                     delai_appui_long=700)
            if retour :
                operateur = retour
        else:
            retour = choix_caractere(chiffres,
                                     delai_attente=60,
                                     delai_appui_long=700)
        if retour :
            operation.append(retour)

    if retour :
        return operation
    else:      
        return None

def affichage_calcul(operation):
    resultat = 0
    if operation :
        item = 0
        for operande in operation:
            item += 1
            if item % 2 == 0:
                operateur = operande
                affichage(operateurs[operateur])
                attendre_boutonA_ou_boutonB(1)
            else:
                affichage(chiffres[operande])
                attendre_boutonA_ou_boutonB(1)
                # Calcul de l'opération
                if item == 1 :
                    resultat = calcul(operande)
                else:
                    resultat = calcul(resultat, operateur, operande)

    return resultat

button = ""   
while True:
    # Saisie de l'opération
    operation = saisie_operation()
    # Affichage de l'opération et calcul de l'opération
    if operation :
        # Affichage et calcul de l'opération
        resultat = affichage_calcul(operation)
        # Affichage du résultat
        button = affichage_nombre(resultat,
                         delai_attente=60,
                         delai_appui_long=700)

    if operation is None or button == "o" :
        # Mise en veille
        display.clear()
        attendre_boutonA_ou_boutonB()

Objectif :

Réalisation d’un programme pour gérer un éclairage arrière personnalisable d’un vélo.

Tu apprendras l’utilisation des boucles For, l’importation des bibliothèques, l’utilisation des tableaux (liste) en python.

Mission :

• Affichage d’une animation fixe.
• Affichage d’une animation dynamique
• Accélération de l’animation par le bouton A
• Allumer ou éteindre l’animation par le bouton B

A découvrir avant de commencer : l’instruction For

En Python, la boucle for est utilisée pour itérer sur une séquence d’éléments tels qu’une liste, une chaîne de caractères, un tuple, un dictionnaire, etc. La boucle for exécute un bloc de code pour chaque élément de la séquence, jusqu’à ce que tous les éléments aient été parcourus.

for element in sequence:

    # Bloc de code à exécuter

Une explication pour chaque élément de la syntaxe :

• Le mot-clé for est utilisé pour déclarer la boucle for.
• element est une variable qui représente l’élément en cours d’itération dans la séquence. Tu peux choisir n’importe quel nom valide pour cette variable.
• Le mot-clé in est utilisé pour spécifier la séquence sur laquelle itérer.
• sequence est la séquence (liste, chaîne de caractères, tuple, etc.) sur laquelle la boucle for va itérer.
• Le bloc de code qui suit le : est indenté et sera exécuté pour chaque élément de la séquence.

Voici un exemple simple pour illustrer son fonctionnement :

liste = [1, 2, 3, 4, 5]

for nombre in liste:

    print(nombre)  # Affiche chaque nombre de la liste

Utilise les indications suivantes pour réaliser ton premier programme. Reproduit le code en caractère GRAS avec l’icône « REPL »

Dans cet exemple, la boucle for itère sur chaque élément de la liste liste. À chaque itération, la variable nombre prend la valeur de l’élément en cours d’itération, puis le bloc de code indenté est exécuté, qui dans ce cas affiche le nombre. La boucle for se répète jusqu’à ce que tous les éléments de la liste aient été parcourus.

Il est également courant d’utiliser la fonction range() en conjonction avec la boucle for pour itérer sur une séquence de nombres. Par exemple :

for i in range(1, 6):

    print(i)  # Affiche les nombres de 1 à 5

Dans cet exemple, range(1, 6) génère une séquence de nombres de 1 à 5 (la borne supérieure spécifiée est exclusive). La boucle for itère sur chaque nombre de cette séquence, assigne la valeur à la variable i, puis exécute le bloc de code indenté.

QCM sur l’instruction FOR

Question 1 : Quelle est la principale utilité de l’instruction « for » en programmation ?

1. Déclarer une fonction
2. Répéter une séquence d’instructions un nombre fixe de fois
3. Gérer les exceptions
4. Établir une condition logique

Question 2 : Comment se structure généralement une boucle « for » en Python ?

1. for (int i = 0; i < 5; i++)
2. for i in range(5):
3. loop (i = 0; i < 5; i++)
4. repeat i in range(5):

Question 3 : Quelle est la fonction de la fonction intégrée range() utilisée fréquemment avec une boucle « for » en Python ?

1. Générer une liste de nombres
2. Calculer la moyenne d’une série de nombres
3. Vérifier la présence d’un élément dans une liste
4. Créer une chaîne de caractères

Question 4 : Comment peut-on sortir prématurément d’une boucle « for » en utilisant l’instruction « break » ?

1. break for
2. break loop
3. exit for
4. break

Question 5 : Quel mot-clé est utilisé pour passer à l’itération suivante dans une boucle « for » sans exécuter le reste du code à l’intérieur de la boucle ?

1. pass
2. skip
3. continue
4. next

Commencer à programmer

Mu est un éditeur de code spécialement conçu pour les microcontrôleurs et plus particulièrement la carte micro :bit.

Utilise le menu « Mode » dans Mu pour choisir « BBC micro ».

Ainsi, tu pourras flasher directement ton programme sur la carte micro.

Choisis de créer un nouveau fichier pour ton programme en cliquant sur « + nouveau », puis demande à enregistrer ton fichier sous le nom de ton choix en utilisant l’option « Enregistrer ».

Bibliothèques à utiliser

from microbit import display

Une bibliothèque en Python est comme une boîte à outils magique pleine de fonctions spéciales que tu peux utiliser pour rendre ton programme plus puissant. Plutôt que de tout créer depuis zéro, tu peux simplement emprunter des outils déjà créés par d’autres personnes.

Pour utiliser une bibliothèque, tu dois l’importer dans ton programme. C’est comme si tu vas à la bibliothèque emprunter un livre pour le lire. En Python, nous utilisons le mot clé import pour faire cela.

Tu vas utiliser deux bibliothèques une pour gérer ton robot et une autre pour gérer le temps.

#Double boucle pour afficher l’éclairage

for c in range(0, 5, 1):
for l in range(0, 5, 1):
      display.set_pixel(c, l, 9)

 Flasher puis bouton reset pour lancer puis vérifie que toutes les LEDs s’affichent

La librairie time pour gérer le temps

from microbit import display
import time
#Boucle sur la colonne pour afficher une LED
for c in range(0, 5, 1):
    #Boucle sur la ligne pour afficher une LED
    for l in range(0, 5, 1):
        #Attente de 300 millisecondes avant affichage de la LED
        time.sleep_ms(300)
        #Affichage de la LED
        display.set_pixel(c, l, 9)

Flasher puis bouton reset puis regarde comment fonctionne les LEDs

Amuse-toi en changeant les valeurs des boucles !!!

• for c in range(2, 5, 1):
• for c in range(0, 3, 1):
• for c in range(0, 5, 2):

• for l in range(2, 5, 1):
• for l in range(0, 3, 1):
• for l in range(0, 5, 2):

 Flasher puis bouton reset entre chaque essai

QCM sur l’importation de bibliothèques (librairies) en Python

Question 1 : Comment peut-on importer une bibliothèque entière en Python ?

1. import microbit
2. include microbit
3. import mocrobit as lib
4. import microbit

Question 2 : Quelle est la méthode recommandée pour importer uniquement une fonction spécifique d’une bibliothèque en Python ?

1. import display from microbit
2. from microbit import display
3. include display from microbit
4. import microbit.display

Question 3 : Comment peut-on vérifier l’existence d’une bibliothèque dans l’éditeur MU ?

1. Vérification manuelle dans le répertoire Python
2. Import library, puis vérification avec la fonction library.check()
3. Utiliser la commande pip show library dans le terminal
4. Vérification avec le bouton du menu « REPL » puis saisir import microbit

Question 4 : Comment connaitre toutes les fonctions d’une bibliothèque dans l’éditeur MU ?

1. List microbit.Image
2. print microbit.Image
3. dir(microbit.Image)
4. show(microbit.Image )

Test si le bouton a ou le bouton b est appuyé

from microbit import display, button_a, button_b

while not(button_a.is_pressed()) and not(button_b.is_pressed()):
            pass

while button_a.is_pressed() or button_b.is_pressed():
            pass

L’instruction while permet de répéter un ensemble d’instructions tant qu’une condition donnée est vraie. Elle est très utile lorsque tu as besoin d’exécuter le même code à plusieurs reprises sans avoir à le réécrire plusieurs fois.

while condition:
    # Code à exécuter tant que la condition est vraie

#Effacement de l’écran
display.clear()

Flasher puis bouton reset et vérifie que l’écran s’éteint après l’appui sur le bouton A ou B

display.set_pixel(…) et button_a.is_pressed() sont des objets de la bibliothèque microbit La première permet d’allumer ou éteindre une LED, la deuxième permet de contrôler les boutons A et B

L’instruction print est un outil précieux pour le débogage en programmation. Elle permet d’afficher des informations spécifiques à un moment donné de l’exécution du programme, ce qui permet de comprendre ce qui se passe dans ton code. Voici pourquoi elle est utile et comment l’utiliser pour le débogage :

Intérêt d’utiliser l’instruction print pour le débogage :

1. Visualisation des données : La principale utilité de print est d’afficher des valeurs de variables, des résultats intermédiaires, ou des messages pour comprendre comment votre programme évolue pendant son exécution.
2. Vérification des états : Vous pouvez utiliser print pour vérifier l’état des variables à différents points de votre code, ce qui te permet de confirmer que les valeurs sont correctes ou de repérer des erreurs potentielles.
3. Traçage de l’exécution : En insérant des déclarations print aux différentes étapes de votre programme, tu peux « tracer » l’exécution du code et suivre son flux pour identifier les erreurs ou les incohérences.

Un exemple :

a = 10
print("La valeur de 'a' est :", a)

Objectif réaliser l’éclairage arrière de ton vélo

Tu veux rendre l’éclairage arrière de ton vélo super cool et dynamique !

Pour cela, tu veux créer un programme avec la carte micro:bit. Voici ce que ton éclairage puisse faire :

1. Choisir ton Animation : Tu veux pouvoir appuyer sur le bouton A pour changer le style de l’éclairage. Chaque fois que tu appuies, l’éclairage passe à une nouvelle animation dynamique.
2. Mettre en Veille : Si tu veux éteindre l’éclairage (peut-être quand tu es à l’arrêt ou que tu n’en as pas besoin), tu appuies sur le bouton B.
3. Automatique : si la lumière du jour est trop forte ou si tu n’as pas bougé pendant un moment, l’éclairage doit se mette en veille tout seul pour économiser.

Maintenant, imagine les animations magiques que tu veux ! Ça pourrait être des clignotements, des pulsations ou même un effet de fondu. Quand tu as une idée, tu peux réaliser ton programme pour rendre ton vélo encore plus génial !

Première animation de l’écran

Objectif de la Mission : Programmer ton éclairage pour allumer toutes les LEDs en une seule fois.

#Bibliothèques à utiliser
from microbit import display, button_a, button_b
import time

Une fonction en programmation est une manière de regrouper un ensemble d’instructions pour effectuer une tâche spécifique.

def ma_fonction():
    # Corps de la fonction

C’est ainsi tu écris et utilises des fonctions en Python. Elles te permettent d’organiser ton code, de le rendre plus lisible et de le rendre plus réutilisable.

#Fonction pour l'affichage du tableau de LEDs
def affichage():
    for c in range(0, 5, 1):
        for l in range(0, 5, 1):
            time.sleep_ms(300)
            display.set_pixel(c, l, 9)

while True:
    #Appel de la fonction d'affichage
    affichage()
    #Attente de l'appui du bouton A ou B
    while not(button_a.is_pressed()) and not(button_b.is_pressed()):
        pass
    while button_a.is_pressed() or button_b.is_pressed():
        pass

    #Effacement de l'écran
    display.clear()

 Flasher puis bouton reset et constate l’animation.

Explication des tableaux ou liste en Python

En Python, les tableaux sont appelés des listes, et ils permettent de stocker une collection ordonnée d’éléments. Les listes peuvent contenir des valeurs de différents types tels que des entiers, des flottants, des chaînes de caractères, et même d’autres listes.

Création d’une liste : Pour créer une liste, tu utilises des crochets [] puis tu sépares les éléments de la liste par des virgules. Par exemple :

liste = [1, 2, 3, 4, 5]

Accès aux éléments d’une liste : Les éléments d’une liste sont accessibles par leur indice, qui commence à 0 pour le premier élément. Tu peux utiliser cet indice entre crochets [] pour accéder à un élément spécifique. Par exemple :

premier_element = liste[0]  # Accès au premier élément
deuxieme_element = liste[1]  # Accès au deuxième élément
print(premier_element)
print(deuxieme_element)

Modification d’un élément de liste : Les éléments d’une liste sont mutables, ce qui signifie qu’ils peuvent être modifiés. Tu peux assigner une nouvelle valeur à un élément spécifique en utilisant son indice. Par exemple :

liste[0] = 10  # Modification du premier élément
print(liste[0])

Longueur d’une liste : Tu peux obtenir la taille (le nombre d’éléments) d’une liste en utilisant la fonction len(). Par exemple :

taille = len(liste)  # Renvoie la taille de la liste
print(taille)

Opérations sur les listes : Les listes en Python offrent de nombreuses opérations utiles, telles que l’ajout d’éléments avec append(), l’insertion d’éléments avec insert(), la suppression d’éléments avec remove() ou del, la concaténation de listes avec +, etc. Tu peux également utiliser des boucles pour itérer sur les éléments d’une liste.

Voici un exemple illustrant certains de ces concepts :

liste = [1, 2, 3, 4, 5]  # Création d'une liste
print(liste[0])  # Affiche le premier élément (1)

liste[2] = 10  # Modification du troisième élément
print(len(liste))  # Affiche la taille de la liste (5)

liste.append(6)  # Ajout d'un nouvel élément (6) à la fin de la liste

for element in liste:
    print(element)  # Affiche chaque élément de la liste

print(len(liste))  # Affiche la taille de la liste (6)

Première animation personnalisée de l’écran

Objectif de la Mission : Programmer ton éclairage pour allumer toutes les LEDs avec l’aide d’un tableau python !

Tu vass utiliser un tableau contenant des chiffres qui correspondent à l’état des LEDs. Ainsi, quand tu changes ces chiffres, tu contrôles la lumière de ton vélo !

from microbit import display, button_a, button_b
import time

# Tableau pour décrire le tableau des LEDs
affichageFixe_1 = [[9, 7, 5, 7, 9],
                   [7, 1, 1, 1, 7],
                   [5, 1, 9, 1, 5],
                   [7, 1, 1, 1, 7],
                   [9, 7, 5, 7, 9]]

# Fonction pour l'affichage du tableau de LEDs
def affichage(animation,vitesse=300):
    l = 0
    for ligne in animation:
        c = 0
        for led in ligne:
            time.sleep_ms(vitesse)
            display.set_pixel(c, l, led)
            c+= 1
        l+= 1

while True:
    # Appel de la fonction d'affichage
    affichage(affichageFixe_1,50)
    # Attente de l'appui du bouton A ou B
    while not(button_a.is_pressed()) and not(button_b.is_pressed()):
        pass

    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Effacement de l'écran
    display.clear()

 Flasher puis bouton reset et change les valeurs dans le tableau : affichageFixe_1 !!

Animation dynamique

Objectif de la Mission : Programmer plusieurs tableaux pour créer une animation dynamique !

from microbit import display, button_a, button_b
import time

# Tableau pour décrire le tableau des LEDs
affichageFixe_1 = [[9, 7, 5, 7, 9],
                   [7, 1, 1, 1, 7],
                   [5, 1, 9, 1, 5],
                   [7, 1, 1, 1, 7],
                   [9, 7, 5, 7, 9]]

affichageFixe_2 = [[0, 0, 9, 0, 0],
                   [0, 0, 9, 0, 0],
                   [9, 9, 9, 9, 9],
                   [0, 0, 9, 0, 0],
                   [0, 0, 9, 0, 0]]

affichageFixe_3 = [[9, 0, 0, 0, 9],
                   [0, 9, 0, 9, 0],
                   [0, 0, 9, 0, 0],
                   [0, 9, 0, 9, 0],
                   [9, 0, 0, 0, 9]]

affichageDynamique = [affichageFixe_1,
                      affichageFixe_2,
                      affichageFixe_3]

# Fonction pour l'affichage du tableau de LEDs
def affichage(animation, vitesse=300):
    l = 0
    for ligne in animation:
        c = 0
        for led in ligne:
            time.sleep_ms(vitesse)
            display.set_pixel(c, l, led)
            c += 1
        l += 1
animation = 0

while True:
    # Appel de la fonction d'affichage
    affichage(affichageDynamique[animation], 10)
    # Attente de l'appui du bouton A ou B
    while not(button_a.is_pressed()) and not(button_b.is_pressed()):
        pass

    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Effacement de l'écran
    display.clear()
    animation += 1

    if animation >= (len(affichageDynamique)):
        animation = 0

 Flasher puis bouton reset et créer ton affichage dynamique !! 

Comment gérer le temps d’affichage de l’image

Objectif de la Mission : Gère dans ton tableau d’animation des temps pour l’affichage des LEDs pour des animations spectaculaires !

affichageDynamique = [[affichageFixe_1, 10],
                      [affichageFixe_2, 200],
                      [affichageFixe_3, 500]]

def affichage(animation, vitesse=300):
    l = 0
    for ligne in animation:
        c = 0
        for led in ligne:
            if led > 0 :
                time.sleep_ms(vitesse)
            display.set_pixel(c, l, led)
            c += 1
        l += 1

et dans le corps principal du programme :

    affichage(affichageDynamique[animation][0],affichageDynamique[animation][1]) 

Flasher puis bouton reset

QCM sur les tableaux (listes) en Python :

Question 1 : Quel est le terme utilisé en Python pour désigner une structure de données ordonnée qui peut contenir différents types d’éléments ?

1. Ensemble
2. Liste
3. Dictionnaire
4. Tuple

Question 2 : Comment créer une liste vide en Python ?

1. list()
2. empty_list()
3. []
4. new List()

Question 3 : Comment accéder au deuxième élément d’une liste en Python (en supposant que l’index commence à 0) ?

1. list[1]
2. list(2)
3. list[2]
4. list.second()

Question 4 : Comment déclarer une liste de listes ?

1. [[],[],[]…]
2. {(),(),()…}
3. new List(new List, new List …)
4. ((),(),()…)

Question 5 : Comment accéder au deuxième élément d’une liste en Python qui est elle-même dans la troisième occurrence d’une liste (en supposant que les index des listes commencent à 0) ?

1. List[2][1]
2. list(2,1)
3. list[3][2]
4. list[3,1]

Animation automatique

Objectif de la Mission : Programme l’enchainement dynamique des tableaux lumineux en utilisant la bibliothèque time et en créant un chronomètre de temps pour gérer la durée d’affichage d’un écran.

# Départ du chronomètre       
def start_chronometre(temps):
    global start
    global chrono
    start = time.ticks_ms()
    chrono = temps

# Si temps du chronomètre écoulé   
def chronometre():
    if time.ticks_ms() - start > chrono :
        return True
    else:
        return False

animation = 0
while True:
    # Appel de la fonction d'affichage
    affichage(affichageDynamique[animation][0], affichageDynamique[animation][1])
    start_chronometre(1000)

    # Attente de l'appui du bouton A ou B ou le chronometre
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           not (chronometre())):
        pass

    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Effacement de l'écran
    display.clear()
    animation += 1
    if animation >= (len(affichageDynamique)):
        animation = 0

 Flasher puis bouton reset

Utilisation de variables globales

Les variables globales en programmation avec Python sont des variables qui sont définies en dehors de toute fonction et qui peuvent être utilisées à n’importe quel endroit du programme. Elles sont accessibles de manière globale, d’où leur nom.

Tu peux utiliser des variables globales lorsque tu as besoin de partager des données entre plusieurs parties de ton programme et que ces données ont une signification globale. Cependant, évite de les utiliser pour des données temporaires ou des valeurs qui ne sont pertinentes que dans des parties spécifiques de ton code. Cela aidera à rendre ton code plus lisible et à éviter des erreurs potentielles.

Si la même information est utilisée dans plusieurs fonctions, une variable globale peut être pratique. Cela évite de passer la valeur en paramètre à chaque appel de fonction.

Si tu as une valeur constante qui reste la même tout au long du programme, tu peux la définir comme une variable globale plutôt que de la répéter à chaque fois dans différentes fonctions.

Rendre variable le temps d’une animation

Objectif de la Mission : Programme pour que le temps d’affichage d’un écran soit variable et que l’on puisse le programmer dans le tableau d’affichage dynamique.

affichageDynamique = [[affichageFixe_1, 10,1000],
                      [affichageFixe_2, 200,5000],
                      [affichageFixe_3, 500,10000]]

 start_chronometre(affichageDynamique[animation][2])

 Flasher puis bouton reset

L’utilisateur peut changer d’animation avec le bouton A

Objectif de la Mission : Donne la possibilité de créer plusieurs animations et que l’utilisateur puisse changer d’animation avec le bouton A.

"""
Enchainement de plusieurs affichages fixes :
 - affichage fixe
 - temps de l'affichage des LEDs de l'affichage fixe
 - temps entre chaque affichage fixe
"""

affichageDynamique_1 = [[affichageFixe_1, 10, 1000],
   [affichageFixe_2, 200, 5000],
   [affichageFixe_3, 500, 10000]]

affichageDynamique_2 = [[affichageFixe_3, 2, 100],
   [affichageFixe_2, 2, 100]]

affichageDynamique_3 = [[affichageFixe_1, 2, 1000],
   [affichageFixe_2, 2, 1000]]

# Liste des affichages dynamiques
affichageDynamique = [affichageDynamique_1, affichageDynamique_2, affichageDynamique_3]

animation = 0
choix = 0
while True:
    # Appel de la fonction d'affichage
    affichage(affichageDynamique[choix][animation][0],
              affichageDynamique[choix][animation][1])
    start_chronometre(affichageDynamique[choix][animation][2])

    # Attente de l'appui du bouton A ou B ou le chronometre
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           not (chronometre())):
        pass

    # Changement du choix de l'animation dynamique
    if button_a.is_pressed():
        choix += 1
        animation = 0

    if choix >= (len(affichageDynamique)):
        choix = 0

    # Attente du bouton relâché
    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Effacement de l'écran
    display.clear()

    # Progression de l'animation de l'affichage dynamique
    animation += 1
    if animation >= (len(affichageDynamique[choix])):
        animation = 0

 Flasher puis bouton reset

Mise en veille du dispositif par le bouton B

Objectif de la Mission : Par le bouton B, l’utilisateur met le dispositif en veille, puis par l’appui du bouton  A ou B l’utilisateur réveille le dispositif.

# Mise en veille du dispositif attendre un appui sur les touches A ou B
def mettre_en_veille():
    display.clear()
    # Attentre que les boutons A et B soient relachés
    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Attentre l’appui d’un bouton A ou A pour le réveil du dispositif
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed())):
        pass

animation = 0
choix = 0
mettre_en_veille()

while True:
    # Appel de la fonction d'affichage
    affichage(affichageDynamique[choix][animation][0],
              affichageDynamique[choix][animation][1])

    start_chronometre(affichageDynamique[choix][animation][2])

    # Attente de l'appui du bouton A ou B ou le chronometre
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           not (chronometre())):
        pass

    # Changement du choix de l'animation dynamique
    if button_a.is_pressed():
        choix += 1
        animation = 0

    if choix >= (len(affichageDynamique)):
        choix = 0

    # Fermeture des animations par l'appui du bouton B
    if button_b.is_pressed():
        mettre_en_veille()

    # Attente du bouton relaché
    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Effacement de l'écran
    display.clear()

    # Progression de l'animation de l'affichage dynamique
    animation += 1
    if animation >= (len(affichageDynamique[choix])):
        animation = 0

Le dispositif se met en veille en plein jour

Objectif de la Mission : Le dispositif se met automatiquement en veille lorsque la luminosité dépasse un seuil de la luminosité du jour.

La carte MICRO :BIT est équipée de plusieurs capteurs, dont un capteur de luminosité. Le capteur de luminosité sur la carte micro:bit est constitué d’une photorésistance (capteur de lumière) qui mesure l’intensité de la lumière réfléchie.

Voici comment vous pouvez utiliser le capteur de luminosité sur la carte micro:bit en programmation avec MicroPython :

from microbit import *

while True:
    # Lire la valeur de luminosité du capteur
    luminosite = display.read_light_level()

    # Afficher la valeur de luminosité sur l'écran LED
    display.scroll("Lum: " + str(luminosite))

    # Pause avant la prochaine mesure
    sleep(1000)

# Initialisation varaible pour la luminosité
def init_luminosite():
    global chrono_luminosite
    chrono_luminosite = time.ticks_ms()       

# Détection si la luminosité actuelle est supérieure à celle de la luminosité du jour
def lec_luminosite():
    global chrono_luminosite
    if display.read_light_level() < LUMINOSITE_JOUR:
        chrono_luminosite = time.ticks_ms()

# Si depuis un certain temps dans la luminosité du jour
def si_luminosite():
    if (chrono_luminosite and
       (time.ticks_ms() - chrono_luminosite > (DELAI_LUMINOSITE*1000))):
        return True
    else:
        return False

# Mise en veille du dispositif attendre un appui sur les touches A ou B
def mettre_en_veille():
    display.clear()
    # Attentre que les boutons A et B soient relachés
    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Attentre l’appui d’un bouton A ou A pour le réveil du dispositif
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed())):
        pass

    init_luminosite()

LUMINOSITE_JOUR = 100
DELAI_LUMINOSITE = 2
animation = 0
choix = 0
mettre_en_veille()

while True:
    # Appel de la fonction d'affichage
    affichage(affichageDynamique[choix][animation][0],
              affichageDynamique[choix][animation][1])
    start_chronometre(affichageDynamique[choix][animation][2])

    # Test de la luminosité
    lec_luminosite()

    # Attente de l'appui du bouton A ou B ou le chronometre
    while (not (button_a.is_pressed()) and
           not (button_b.is_pressed()) and
           not (chronometre())):
        pass

    # Changement du choix de l'animation dynamique
    if button_a.is_pressed():
        choix += 1
        animation = 0

    if choix >= (len(affichageDynamique)):
        choix = 0

    # Fermeture des animations par l'appui du bouton B
    if button_b.is_pressed():
        mettre_en_veille()

    # Si luminosité du jour depuis un certain temps alors mise en veille

    if si_luminosite():
        mettre_en_veille()

    # Attente du bouton relaché
    while button_a.is_pressed() or button_b.is_pressed():
        pass

    # Effacement de l'écran
    display.clear()

    # Progression de l'animation de l'affichage dynamique
    animation += 1
    if animation >= (len(affichageDynamique[choix])):
        animation = 0