Documentation BBC micro:bit MicroPython

• Connexion du micro:bit au ordinateur
• Chargement de programmes au micro:bit

BBC micro:bit est une plaque de développement qui utilise un microcontrôleur. Ce dispositif a pour but d’offrir les étudiants un bon commencement pour développer ses compétences en programmation.

Micro:bit V2 est un ARM Cortex M4, petit et facile d’utiliser. Il est prévu avec 25 LED, sur lesquelles on peut afficher des messages ou des images. Il est prévu, aussi, avec u accéléromètre, qui peut détecter les mouvements, un bussole, Bluetooth, deux buttons, à travers lequel il peut interagir avec l’utilisateur et des autres d’autres capteurs que nous découvrirons au cours du TP.

Les programmes seront écrits sur l’ordinateur et après ils seront chargés sur le micr:obit. Ces programmes restent sur la mémoire flash et ils vont être exécutés quand le microcontrôleur est alimenté.

Qu’est-ce qu'un microcontrôleur?

Le microcontrôleur et un ordinateur réduit dans un seul chip, qui peut exécuter un programme à la fois et consommer beaucoup moins qu’un ordinateur portable ou un ordinateur. En plus, elles sont bonnes pour contrôler et détecter les signaux électriques a l’aide de ses broches. Pour plus des infos tu peux cliquer sur ce lien.

Pour le déploiement des TP, on va utiliser Micropython pour écrire des programmes sur micro:bit. Micropython est un langage de programmation crée pour travailler avec des microcontrôleurs.

Si vous avez une BBC micro:bit V2 passez à la section "La connexion du micro:bit".

Si tu n'as pas un BBC micro:bit suivez les instructions ci-dessous pour utiliser le simulateur.

Le simulateur MicroPython peut également être utilisé pour réaliser les laboratoires. Pour pouvoir l'utiliser, vous devez taper les commandes suivantes dans le terminal, si vous utilisez Windows, tapez les commandes dans cmd.

Si vous n'avez pas installé Python3 ou si vous n'êtes pas sûr de l'avoir, suivez les étapes de ce document.

L'étape suivante est de taper les commandes suivantes:

git clone https://github.com/ducklord420/PythonEditor.git
cd PythonEditor
git submodule update --init --recursive
py -m http.server --bind 0.0.0.0

Pour accéder le simulateur ouvrir un browser et ouvrez: http://localhost:8000/editor.html

Pour simuler le code, cliquez sur “Sim”. Testez l ' Exemple 1 du section suivante.

Le premier pas pour connecter le microcontrôleur a l’ordinateur est d’utiliser le câble micro USB, qui a été reçu avec BBC micro:bit. Vous devez introduire le USB type B en haut du dispositif et l’autre terminaison de fil dans votre ordinateur.

Pour le développement des TP, on va écrire des programmes dans un éditeur du code en ligne, qui s'appellent Makecode.

Le premier exemple qu’on va l'écrire sera l'affichage de texte “Hello” sur le 25 LED, suivi par l'abréviation “SdE”, qui toutefois va être stocke dans une variable.

from microbit import display  #import "diplay" from microbit library
 
name = "SdE" #declaration of a variable with a String
 
#all the code that is idented under the loop belongs to it
while True: #infinite looop
    # "display" is an object that refers to the LEDs, this method allows us to control them
    display.scroll("HELLO" + " " + name) # concatenation of Strings
 

Le transfert du programme s'appellent flashing, parce que le programme est copié dans la mémoire flash du micro:bit.

Après que vous avez eu connectée le microcontrôleur a l'ordinateur vous pouvez voir “MICROBIT” comme une clé USB.

L’étape suivante est de sauve-garder le programme comme un fichier .hex. Pour cela on doit appuyer sur le bouton “Load/Save”, alors il sera téléchargé, comme on peut voir dans l’image ci-dessous:

La dernière étape pour charger le programme sur micro:bit est d'ouvrir le dossier ou a été télécharge le fichier .hex et lui copier dans “MICROBIT”. se compilera automatiquement sur le microcontrôleur.

La première étape est de connecter le dispositif en appuyant le bouton “Connect” depuis le menu de l’éditeur de code.

Une fenêtre similaire à celle ci-dessous apparaîtra. Il ne reste plus qu’à cliquer sur le dispositif “BBCmicrobit” que Makecode a détecte.

La dernière étape c’est d’appuyer le bouton “Flash”. Il y a possible que vous devez attendre quelques secondes jusqu’à le programme va être charge sur micro:bit.

Contrairement aux autres langages de programmation, en Python il ne faut pas déclarer les variables ou leur type avant de les utiliser. De ce point de vue, Python fait partie de la catégorie des langages de programmation dynamiquement typés, où le type des variables n'est interpété qu'au moment de l'exécution.

Python supporte 2 types numériques: entiers et réels.

# Syntaxe pour déclarer un numéro entier:
myInt = 7
 
# Syntaxe pour déclarer un numéro réel:
myFloat = 7.0
myFloat = float(7)

myString = 'hello'
myString = "hello"

On peut réaliser l'attribution des valeurs aux plusieurs variables simultanément, mais sans mélanger les valeurs numériques avec les strings:

# Instructions valides
a, b = 1, 2             
suma = a  + b

# Instructions valides
hello = "hello"
world = "world"
message = hello + " " + world

# Cela ne va pas fonctionner
 
one = 1
two = 2
three = 3
hello = "hello"
 
print (one + two + three + hello)

one = 1
two = 2
three = 3
hello = "hello"
 
print ( str(one) + str(two) + str(three) + hello )

Les listes sont similaires aux array. Elles peuvent contenire n'importe quel type de variables et le nombre des éléments n'est pas limité.

Pour créer une liste qui contient des éléments de type entier on va utilise la suivante ligne de code:

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

On peut créer une liste vide, auquel on va ajouter des éléments:

# Déclaration de la liste
 
mylist = []
 
# Insertion des éléments
 
mylist.append(1)
mylist.append(2)
mylist.append(3)

En extraire un élément d'une liste on va utiliser une construction de type liste[indice]:

mylist = [1,2,3]
 
# On affiche chaque élément
 
print( mylist[0] )
print( mylist[1] )
print( mylist[2] )
 
# Output
1
2
3

Pour créer une liste avec des éléments entiers, on va utiliser la fonction range, qui va retourne une liste avec toutes les numéros entiers d'un certain intervalle. La fonction a la suivante définition: range(start, stop, pas), où start est la première valeur dans la liste, stop est la valeur d'arrêter (la valeur n'est pas incluse), pas est le pas d' incrémentation et est un paramétré optionnel (la valeur défauts est 1).

Exemple

Pour créer une liste avec des valeurs paires de 2 a 12, on va avoir la suivante ligne de code:

mylist = range (2, 13, 2)

• cmp( listName1, listName2) → comparer les éléments des 2 listes
• len( listName ) → numéro des éléments de la liste
• max( listName ) → l'élément ayant la valeur maximale
• min( listName ) → l'élément ayant la valeur minimale

• listName.append( element ) → insérer un élément a la fin de la liste
• listName.count( element ) → nombre d'occurrences de l'élément dans la liste
• listName.index( element ) → index de la première occurrence de l'élément dans la liste
• listName.insert( index, element ) → insertion de l'élément à l'index indiqué dans la liste
• listName.pop() → supprime et renvoie le dernier élément de la liste
• listName.remove( element ) → supprime le dernier élément de la liste
• listName.reverse() → inverser l'ordre des éléments dans la liste
• listName.sort( [function] ) → trier les éléments de la liste selon la fonction indiquée

Un dictionnaire est une structure de données, similaire aux vecteurs ou aux listes, mais fonctionne avec des valeurs et des clés au lieu des indices. Chaque valeur stockée dans un dictionnaire peut être accessible à l'aide d'une clé, représentée par n'importe quel type d'objet (une chaîne, un nombre, une liste, etc.), au lieu d'utiliser un index pour l'adresser.

Par exemple, les dictionnaires peuvent être utiles pour implémenter des bases de données. Supposons que nous ayons une base de données d'étudiants et que nous devons retenir la spécialisation pour laquelle chacun d'entre eux a opté.

Déclarer un dictionnaire

specialisation = {}
 
specialisation["Ana"] = "Informatique"
specialisation["Radu"] = "Electronique"

Ou bien

specialisation = {
   "Ana": "Informatique",
   "Radu": "Electronique"
}

Parcourir les éléments d'un dictionnaire

for nom, spec in specialisation.iteritems():
   print ("Le nom de l'optionel ou {} a été répartisé est: {}".format(nom, spec))

Eliminer des valeurs d'un dictionnaire

del optionalRepartizare["Ana"]
 
# ou
 
optionalRepartizare.pop("Ana")

Propriétés des clés dans un dictionnaire

Dans un dictionnaire, on n'a pas de restrictions pour les valeurs, mais les clés doivent etre uniques. Au cas ou on ne respecte pas cette propriété et on a 2 entrées ayant la meme clé, seulement le dernier enregistrement va rester valide. Par exemple, pour la suivante séquence de code:

age = {
    "Ana" : 14,     
    "Ioana" : 13,     
    "Ana" : 16,     
    "Ioana" : 22,     
    "Ana" : 11
}
 
print ("Ana a  {} années et Ioana a {} années.".format(age["Ana"], age["Ioana"]))

On va afficher le message suivant: “Ana a 11 années et Ioana a 22 années.”

• cmp(dictionarUnu, dictionarDoi) → comparer les éléments des 2 dictionnaires
• len(numeDictionar) → numéro des éléments d'un dictionnaire
• str(numeDictionar) → génère une version facile a afficher du dictionnaire

• numeDictionar.clear() → éliminer toutes les éléments du dictionnaire
• numeDictionar.copy() → retourne une copie du dictionnaire
• numeDictionar.get(key, default=None) → la valeur contenue dans le dictionnaire pour la cle “key”, ou la valeur “default” sinon
• numeDictionar.has_key(key) → “true” s'il y a un enregistrement avec la clé indiquée et “false” sinon
• numeDictionar.items() → une liste avec toutes les paires du type (clé, valeur) qui se trouvent dans le dictionnaire
• numeDictionar.keys() → liste des clés
• dictionar1.update(dictionar2) → ajoute le contenu du dictionnaire dictionar2 dans le dictionnaire dictionar1
• numeDictionar.values() → liste avec toutes les valeurs stockées dans le dictionnaire

# Décision simple
 
a = 33
b = 200
if b > a:
  print("b is greater than a")

# Utiliser elif pour ajouter une condition supplémentaire
 
a = 33
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")

# Le mot clé else prend tout ce qui n'a pas été inclus avant
 
a = 200
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

# Else sans elif
 
a = 200
b = 33
if b > a:
  print("b is greater than a")
else:
  print("b is not greater than a")

Contrairement aux autres langages, qui ont la forme standard for(…) { code } pour la boucle for, Python élimine les parantheses qui marquent l'itération d'une liste et utilise les : pour indiquer le début du bloc de code qui sera exécuté a l'intérieur de la boucle, comme dans l'exemple suivant:

listaDeNume = ["Ana", "Maria", "Ioana", "Irina", "Andreea", "Cristina"]
 
for nume in listaDeNume:
    print (nume)

En Python, l'indice du pas ou l'on se trouve a chaque moment lorsqu'on parcourt une séquence n'est pas visible. Cependant, il y a une méthode pour compter les pas: la fonction enumerate:

cours= [ "Analyse", "SdE", "ALF"]
 
 
for index, hobby in enumerate(cours):
    print (index, hobby)
 
# Output:
0 Analyse
1 SdE
2 ALF

Une autre fonctionnalité est l'utilitaire zip, qui permet de parcourir 2 listes simultanément:

lista1 = [ 3, 9, 17, 15, 19]
lista2 = [ 2, 4, 30, 24, 3]
 
for a, b in zip( lista1, lista2 ):
    if a > b:
        print (a)
    else:
        print (b)
 
# Output:
 
3
9
30
24
19

Une autre particularité du langage Python est le fait qu'on peut appliquer la condition “else” aussi pour la boucle “for”. Dans ce cas, la branche “else” sera executée après la boucle “for”, si et seulement si à l'intérieur de “for” on n'a pas une déclaration de type “break”. Par exemple:

listeAnimaux = [ "loup", "lapin", "lion", "ours" ]
 
for i in listeAnimaux:
   print (i)
   if i == "lapin"
     print ("Le lapin n'est pas sauvage")
     break
else:
   print ("Tous les animaux!")
 
# Output
loup
lapin
Le lapin n est pas sauvage
 
#Si on execute la sequence suivante:
for i in listeAnimaux:
   print (i)
   if i == "lapin"
     print ("Le lapin n'est pas sauvage")
else:
   print ("Tous les animaux!")
 
# Output
loup
lapin
Le lapin n est pas sauvage
lion
ours
Tous les animaux!

#Afficher les chiffres de 0 a 9
 
count = 0
 
while count < 10:
    print (count)
    count = count + 1

Comme pour la boucle “for” on a aussi la possiblité d'appliquer la condition “else” a la boucle “while”. La différence est que le bloc “else” sera exécuté chaque fois que la condition de la structure répétitive sera évaluée comme fausse:

print ("Dévinez de numéro de l'intervalle [ 1, 10 ]")
 
monNr = 7
votreNr = 0
 
while votreNr!= monNr:
    votreNr = int( input("Choisissez. ") )
else:
    print ("Félicitations!")

L'instruction “break” est utilisée pour sortir d'une structure répétitive, en étant une alternative pour la condition de sortie. Par exemple, on peut afficher les numéros de 0 a 9 de la facon suivante:

count = 0
 
while True:
    print (count)
    count = count + 1
    if count > 10:
        break

La déclaration “continue” est utilisée pour ignorer un bloc d'instructions. Par exemple, on peut l'utiliser pour afficher les nombres pairs de 0 a 20:

number = 0
 
while number < 21:
    if number % 2 == 1
        continue
    print (number)

def myFunction():
   print ("Welcome")
 
# ou
 
def simpleSum( a, b ):
   return a + b

myFunction()
 
# ou
 
first = 1
second = 1
sum = simpleSum( first, second )
print (sum)
 
print (simpleSum( first, second ))

On appelle objet une encapsulation de variables et fonctions dans une seule entité, tandis qu'une classe représente un modèle pour la création des objets. Donc, in objet prend ses données d'une classe.

# Classe simple
 
class MaClasse:
   variable = "Bonjour"
 
   def maFonction(self):
      print ("Bonjour de l'autre part!")
 
 
# Association classe objet
monObjet = MaClasse()
 
 
# Afficher le contenu de la variable de MaClasse
print (monObjet.variable)
 
# Appeler la fonction maFonction, qui va afficher sur l'écran le message "Bonjour de  l'autre part!"
monObjet.maFonction()

Le nombre d'objets qu'on peut créer a partir d'une classe n'est pas limité, tous les objets en héritant touts les particularités de la classe (variables et fonctions). Cependant, chaque objet contient des copies indépendantes des variables définies a l'interieur de la classe. Donc, si on crée un nouvel objet de la classe mere, on peut modifier son contenu sans affecter la definition initiale de la classe:

class MaClasse:
   variable = "Bonjour"
 
   def maFonction(self):
      print ("Bonjour de l'autre part!")
 
monObjet1 = MaClasse()
monObjet2 = MaClasse()
 
monObjet2.variable = "au revoir"
 
print (monObjet1.variable)
print (monObjet2.variable)
 
#Output
bonjour
au revoir

Pour pouvoir utiliser des fonctions qui exécutent des opérations mathématiques en Python, il faut importer et utiliser le module math.

import math

math.functionName( params )

functionName( params )

Comme l'entrée des données peut provenir du clavier en nombreuses situations, Python 3 fournit la fonction input(). Cette fonction peut recevoir aussi un parametre supplémentaire, qui sera le string affiché dans la ligne de commande au moment de la lecture des données nécessaires:

name = input("Quel est votre nom? ")
print("Bienvenue, " + name + "!")

# Output dans la ligne de commande
Quel est votre nom? "Ana"
Bienvenue, Ana!

En Python, on a 2 types d'erreurs: erreurs de syntaxe et exceptions.

Les erreurs de syntaxe, connues aussi sur le nom d'erreurs d'analyse (parsing error) sont les plus communes:

>>> while True print('Hello world')
  File "<stdin>", line 1
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

Les exceptions sont détectées au moment de l'exécution:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Pour gérer les exceptions en Python, on utilise le bloc try - except, comme dans l'exemple suivant:

while True:
    try:
        x = int(input("Please enter a number: "))
        break
    except ValueError:
        print("Oops!  That was no valid number.  Try again...")

1. Créez 3 variables de types différents, comme il suit: (0.5p)
   1. une variable “int”, qui va recevoir la valeur 80
   2. une variable “float”, ayant la valeur 20.2
   3. une variable “string”, qui va retenir la chaîne “python”
2. En utilisant la fonction type, déterminez le types des variables suivantes: (0.5p)
   1. var1 = 80
   2. var2 = 20.2
   3. var3 = “microbit”
3. Ecrivez un programme qui recoit comme parametres de la ligne de commande 4 nombres (a,b,c,d) et affiche sur l'écran le résultat de l'opération a+b*c+d. (1p)
4. Créez une liste avec les noms des camarades de classe. Les noms peuvent ne pas etre distincts. Résolvez les demandes suivantes: (2p)
   1. Copier la liste intaille dans une autre liste appelle copyList et trier lui dans l ordre alphabétique.
   2. Déterminez le numéro d'occurrences du chaque nom en utilisant une liste auxiliaire, qui contient des éléments distincts.
   3. Déterminez le nom, qui a le numéro maxime d'occurrences dans la liste initiale et le nom avec le numéro minime d'occurrence (s’il y a plusieurs éléments qui respect la condition toutes vont être affichées).
   4. Inversez la liste de copyList et supprimez le dernier élément de la liste initiale.
5. Créez une base de données d'un magasin avec des appareils électroménagers à l'aide du dictionnaire. Ajoutez des fonctionnalités: lorsqu'un produit est lu à partir du clavier, son prix soit affiché. Une erreur s'affichera si le produit n'existe pas “Erreur” et les produits seront recherchés jusqu'à ce que le texte “stop” soit entré.
6. Ecrivez un programme qui affichera le résultat retourne par la fonction digitize (n) . Cette fonction va recevoir un int comme paramètre et va retourner une liste de chiffres du nombre dans l'ordre inverse. (1p) Exemple: 348597 ⇒ [7,9,5,8,4,3]
7. Créez une classe Capteurs utilisée pour stocker les valeurs des capteurs suivants: température, lumière, humidité. Pour chaque capteur, vous pouvez lire et modifier les valeurs par des appels de fonction. (1p)
8. Créez un programme qui, en utilisant la classe définie ci-dessus, stocker des valeurs provenant du différent ensembles de capteurs pour les suivantes chambres d'une maison et les affiche à l'écran: la cuisine, le hall, la chambre a couché, la salle a mangé. Le programme effectue les opérations en recevant les commandes de la console comme suit: (2p)
   • insert <chambre> <capteru> <valeur> - où <chambre> , <capteur> et <valeur> vont être remplacés avec un de les 3 capteurs et une valeur - insérer une nouvelle valeur pour le capteur respectif
   • delete <chambre> <chambre> <capteru> <valeur> - supprimer la valeur de ce capteur, la valeur après suppression sera 0
   • print <chambre><sensor> - afficher la valeur pour le capteur de la chambre précise
   • print <chambre> - afficher tous capteurs el les valerus correspondantes pour la chambre spécifiée
   • add_room <chambre> - ajoute un nouvel ensemble de capteurs pour une nouvelle chambre
   • del_room <chambre> - efface l'ensmeble de capteurs pour une chambre

S’il va être introduit une autre commande, le programme lèvera une exception.

1. Modifiez les programmes précédents pour afficher les valeurs sur micro: bit, pas sur la console.
2. Créez un programme qui allume tour à tour chaque LED du micro:bit.
3. Créez un programme qui lit la température ambiante à l'aide du capteur existant sur micro:bit et l'affiche à l'aide des LED.

Solutions