Catégories
MICRO PYTHON MICRO:BIT

Eclairage vélo

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