Depuis des années maintenant,
Texas Instruments réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à tous et toutes. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets imaginables sans avoir à se concentrer sur des difficultés annexes.
Nous pouvions déjà citer l'interface
TI-Innovator Hub, le robot pilotable
TI-Innovator Rover, la grille programmable
TI-RGB Array ou encore l'adaptateur
TI-SensorLink pour capteurs analogiques
Vernier.
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python des calculatrices concernées, faisant de l'écosystème
Texas Instruments le seul
Python connecté !
Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous partagent le même langage de programmation, notamment en
SNT, spécialité
NSI,
SI et
Physique-Chimie, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant !
Et
depuis la rentrée 2020 dernière grande révolution en date, plus besoin de t'équiper en
TI-Innovator pour bénéficier de ces formidables avantages. En effet, la
TI-83 Premium CE Edition Python française s'est vu rajouter la gestion du nanoordinateur
BBC micro:bit programmable en
Python dont tu étais peut-être déjà équipé·e !
La carte
micro:bit est initialement un projet lancé par la
BBC (British Broadcasting Corporation), le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont
ARM,
Microsoft et
Samsung. Elle fut distribuée gratuitement à un million d'élèves britanniques de 11 et 12 ans.
Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique
BBC Micro des années 1980, l'équivalent britannique de par son adoption à nos microordinateurs
Thomson MO5 et
TO7 inondant écoles, collèges et lycées à la fin de cette décennie dans le cadre du plan
IPT (Informatique Pour Tous).
Les cartes
micro:bit utilisent un connecteur
micro-USB et ta calculatrice un
mini-USB.
Pour relier les deux une solution est d'adjoindre un
adaptateur mini-USB.
Pour moins d'encombrement, tu as aussi la solution d'utiliser un
câble direct, au choix :
- USB micro-B mâle ↔ USB mini-A mâle
- USB micro-B mâle ↔ USB mini-B OTG mâle
La carte
micro:bit dans ses versions 1 est programmable en
Python et présentait initialement les caractéristiques et capacités suivantes :
- processeur 32 bits ARM Cortex-M0 cadencé à 16 MHz
- mémoire de stockage Flash d'une capacité de 256 Kio
- mémoire de travail RAM d'une capacité de 16 Kio permettant un heap (tas) Python de 10,048 Ko
- un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
- nombre de capteurs intégrés :
- capteur de luminosité (lié aux diodes)
- capteur de température (sur le processeur)
- 2 boutons poussoirs
A
et B
programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez Nintendo - accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
- boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
- connectivité Bluetooth 4.0 basse énergie 2,4 GHz maître/esclave
Depuis début 2021 est disponible la nouvelle carte
micro:bit v2.
Elle utilise un tout nouveau microcontrôleur, le
nRF52833, toujours de chez
Nordic Semiconductor. Cette fois-ci nous avons des spécifications qui devraient nous permettre de respirer :
- processeur 32 bits ARM Cortex-M0 cadencé à 64 MHz au lieu de 16 MHz soit 4 fois plus rapide !
- mémoire de stockage Flash d'une capacité de 512 Kio au lieu de 256 Kio soit 2 fois plus grande !
- mémoire de travail RAM d'une capacité de 128 Kio au lieu de 16 Kio soit 8 fois plus grande, permettant un heap (tas) Python de 64,512 Ko !
Elle apporte sur cette même face plusieurs nouveautés ou changements :
- ajout d'un haut-parleur
- ajout d'un microphone MEMs
- bouton poussoir qui ne sert plus seulement à la réinitialisation (reset), mais permet désormais également d'éteindre la carte (appui long) et de la rallumer (appui court)
- l'antenne Bluetooth qui devient compatible BLE Bluetooth 5.0, contre seulement 4.0 auparavant
D'autres nouveautés ou changements sont également présents sur l'autre face :
- ajout d'une diode DEL indiquant l'état du microphone
- ajout d'un bouton tactile sur le logo micro:bit, voici pourquoi il perd sa couleur au profit de contacts métalliques
Expliquons brièvement la composition de la solution de connectivité
BBC micro:bit de
Texas Instruments, ainsi que son fonctionnement.
Le solution se compose d'une part d'un fichier
TI-Runtime unique à copier sur la carte
micro:bit v1 ou
v2 et qui lui permet d'être pilotée par la calculatrice. La bonne installation du fichier est aisément vérifiable, puisque faisant afficher à la carte le logo
Texas Instruments.
La solution a un principe de fonctionnement très simple, mais non moins ingénieux pour autant. La carte
micro:bit étant justement programmable en
Python, une fois le
TI-Runtime installé elle se met alors à écouter les commandes
Python envoyées depuis la calculatrice et à les exécuter.
Depuis ta calculatrice, tu peux envoyer n'importe quelle commande
Python à ta carte
micro:bit et profiter pleinement de ses capacités grâce à la fonction
ti_hub.send(), à condition d'encadrer la commande des bons caractères de contrôle. Voici une fonction
mb_run() en ce sens :
- Code: Tout sélectionner
from ti_hub import *
def mb_run(code):
send('\x05') # enter paste mode (Ctrl-E)
send(code)
send('\x04') # exit paste mode (Ctrl-D)
Pour afficher par exemple
Pac-Man, il te suffit d'appeler
mb_run("display.show(Image.PACMAN)"), conformément à la documentation du
Python micro:bit.
Toutefois en pratique dans le contexte scolaire, cette façon de faire n'était pas idéale. Elle rajoutait un niveau d'imbrication : tu devais produire du code Python qui lui-même devait construire le code Python à exécuter par la carte micro:bit, une marche sans doute un peu haute pour bien des élèves débutants.
Et bien justement,
Texas Instruments est loin de s'être arrêté là. Sa solution de connectivité comporte également des bibliothèques
Python additionnelles à charger sur ta calculatrice, au choix en Français ou Anglais, et rajoutant alors des menus permettant de faire appel plus simplement aux éléments correspondants sur la carte
micro:bit. 9 bibliothèques étaient initialement disponibles, facilitant ainsi l'utilisation de certaines bibliothèques du
Python micro:bit :
- microbit (générale, permet d'accéder aux menus des autres bibliothèques)
- mb_butns → microbit.buttons (boutons A et B intégrés - importée/accessible via le menu Buttons ou Boutons)
- mb_disp → microbit.display (afficheur à 5×5=25 LEDs rouges intégré - importée/accessible via le menu Display ou Affichage)
- mb_grove (capteurs et actionneurs Grove à rajouter - importée/accessible via le menu Grove)
- mb_music → microbit.music (haut-parleur à rajouter sur micro:bit v1 ou intégré sur micro:bit v2 - importée/accessible via le menu Music ou Musique)
- mb_neopx → microbit.neopixel (rubans de LEDs programmables à rajouter - importée/accessible via le menu NeoPixel)
- mb_pins (contacts programmables intégrés - importée/accessible via le menu Input/output pins ou Broches entrée/sortie)
- mb_radio → microbit.radio (communication radio intégrée - importée/accessible via le menu Radio)
- mb_sensr (capteurs intégrés : boussole, accéléromètre, température - importée/accessible via le menu Sensors ou Capteurs)
La
mise à jour 2.4 du
TI-Runtime avait rajouté la compatibilité avec la nouvelle carte
micro:bit v2, mais hélas rien concernant ses nouvelles capacités.
On pouvait juste noter que le code écrit avec la bibliothèque
mb_music et ciblant donc initialement un haut-parleur externe connecté sur
micro:bit v1, marchait sans le moindre changement directement avec le haut-parleur interne de la
micro:bit v2.
Mais mis à part cela, tous les autres nouveaux éléments de la
micro:bit v2 t'étaient inaccessibles, du moins via les menus de la calculatrice.
Et bien justement, Texas Instruments nous sort aujourd'hui une mise à jour majeure de sa solution de connectivité micro:bit pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition et TI-84 Plus CE Python.
Découvrons donc ensemble les nouveautés.
Avec cette mise à jour,
Texas Instruments fait le choix de scinder sa solution de connectivité
micro:bit en deux. En effet à compter d'aujourd'hui tu devras choisir entre 2 packs de fichiers différents selon la carte
micro:bit que tu utilises :
- un pack avec des fichiers en version 1 pour une micro:bit v1
- un pack avec des fichiers en version 2 pour une micro:bit v2
La numérotation est donc sans lien logique avec les versions déjà diffusée. Les fichiers des packs d'aujourd'hui sont en version
1.0.0 et
2.1.0.
Chaque pack de fichiers se compose donc :
- du fichier TI-Runtime pour la carte micro:bit
- de non plus 9, mais 11 à 13 bibliothèques Python pour ta calculatrice
À noter que sauf erreur de notre part, cette mise à jour n'a été diffusée qu'en Anglais, pas encore en Français. Comme illustrés ci-après, les menus permettant les nouvelles possibilités sur calculatrice seront donc en Anglais.
Attention, les nouvelles nouvelles bibliothèques
Python ne fonctionneront pas correctement avec les cartes
micro:bit munies d'une ancienne version du
TI-Runtime.
Dans ce cas tu obtiendras une erreur de connexion dès l'importation de la bibliothèque.
Chose très pénible avec les bibliothèques
microbit des versions précédentes pour ta calculatrice, elles n'étaient pas par défaut au menu.
Elles n'étaient présentes au menu que lorsque tu éditais un script contenant une ligne les important, par exemple
from microbit import *. Et donc pour un nouveau script, tu devrais saisir cette ligne intégralement à la main, caractère par caractère, au clavier de ta calculatrice, opération très fastidieuse...
Et bien excellente chose, les nouvelles bibliothèques codées par
TI ont cette fois-ci été converties en fichiers pour ta calculatrice avec le tout dernier
py2appvar 1.2.1, et peuvent ainsi être reconnues en tant que bibliothèques complémentaires par la dernière
version 5.7 de l'application
Python de ta calculatrice
(nécessitant elle-même la mise à jour système 5.7).
C'est justement le cas de la bibliothèque
micropython. À partir de la liste des bibliothèques intégrées, l'onglet de bas d'écran
Compl. lié à la touche
F4
te permet de saisir le
from microbit import * d'une seule touche pour activer le menu
microbit !
Commençons par les nouveautés communes à toutes les cartes
micro:bit.
Le menu disponible suite à l'importation de la bibliothèque
microbit fait apparaître non plus 8 mais 9 bibliothèques.
Nouveauté évidente donc
Data Logging (Enregistrement de données) correspondant à la bibliothèque
mb_log.
Il y a également une autre nouvelle bibliothèque. Le choix
Music (Musique) importe désormais non seulement la bibliothèque
mb_music, mais également une nouvelle bibliothèque
mb_notes.
Nouveauté également au menu, un nouvel onglet
Commands (Commandes).
Il nous permet d'avoir directement sous la main différentes méthodes bien utiles en provenance d'autres bibliothèques :
- sleep() pour patienter (builtins)
- escape() pour attendre l'appui sur la touche
annul
ou clear
(ti_system) - disp_clr() pour effacer l'écran (ti_system)
- store_list() pour enregistrer une liste de nombres dans l'environnement de la calculatrice (ti_system)
- et bizarrement temperature()
temperature() était jusqu'à présent fourni par la bibliothèque
mb_sensr dédié à l'interrogation des capteurs intégrés à la
micro:bit, et c'est ainsi curieux qu'il se retrouve tout seul ici. Mais c'est un capteur à part, puisque c'est le seul qui n'effectue par une mesure externe mais interne. En effet ce n'est pas la température de l'environnement qu'il retourne, mais la températeur du processeur de la
micro:bit.
Nous regarderons les nouvelles bibliothèques plus loin, commençons pour le moment par les changements apportés aux bibliothèques par rapport à la version précédente.
Le choix
Display ou
Affichage permet d'importer la bibliothèque
mb_disp et activer son menu. Cette bibliothèque te permet de contrôler facilement la grille de diodes adressables.
Tu pouvais au choix :
- afficher des images prédéfinies
- créer tes propres images à afficher au format micro:bit
- contrôler individuellement chaque pixel
Pour afficher par exemple
Pac-man, le menu te permettait de construire facilement l'appel
display.show("Image.PACMAN").
35 noms d'images prédéfinies pouvaient être saisis très facilement grâce à l'onglet
ImagesToutefois la carte
micro:bit connaît bien davantage d'images que ça. Il nous manquait :
- 12 images d'horloge CLOCK
- 8 images de flèches ARROW
- BUTTERFLY, STICKFIGURE, GHOST, SWORD, GIRAFFE, SKULL, UMBRELLA et SNAKE
Pourquoi ?
Texas Instruments limite volontairement à 36 le nombre d'éléments dans les menus, afin qu'ils soient tous accessibles via un raccourci clavier à 1 touche. Or, nous ne disposons que de 10 chiffres et 26 lettres.
Tu pouvais parfaitement utiliser les images non listées au menu, mais il te fallait en connaître le nom et le saisir manuellement.
Pour afficher le papillon par exemple, tu devais donc saisir ou corriger ta saisie en
display.show("Image.BUTTERFLY").
Nouveauté donc,
Texas Instruments nous déplace la commande permettant de créer tes propres images de l'onglet
Images vers l'onglet
Display (Affichage).
À la place,
Texas Instruments te rajoute un 36
ème nom d'image prédéfinie dans l'onglet
Images, justement le
BUTTEFLY (papillon) !
- Code: Tout sélectionner
from microbit import *
from mb_disp import *
boat = Image("05050:""05050:""05050:""99999:""09990")
spin1 = Image("00900:""00900:""00900:""00900:""00900")
spin2 = Image("00090:""00000:""00900:""00000:""09000")
spin3 = Image("00009:""00090:""00900:""09000:""90000")
spin4 = Image("00000:""00009:""00900:""90000:""00000")
spin5 = Image("00000:""00000:""99999:""00000:""00000")
spin6 = Image("00000:""90000:""00900:""00009:""00000")
spin7 = Image("90000:""09000:""00900:""00090:""00009")
spin8 = Image("09000:""00000:""00900:""00000:""00090")
spinner=[spin1,spin2,spin3,spin4,spin5,spin6,spin7,spin8]
flash = [Image().invert(i) for i in range(9, -1, -1)]
disp_clr()
print("Display and Image Test")
print("display.clr")
display.clear()
print("display.show('Image.HEART, delay = 3000, wait = True')")
display.show("Image.HEART",delay=3000, wait = True)
print("display.show(1.4142)")
display.show(1.4142)
print("brightness =",display.read_light_level())
print("display.scroll('Fast as a Fox', delay = 50)")
display.scroll("Fast as a Fox",delay=50,wait=True)
print("display.scroll('Slow as Molasses', delay = 200)")
display.scroll("Slow as Molasses",delay=200,wait=True)
print("display.set_pixel(x,y,i)")
display.set_pixel(1,0,9)
display.set_pixel(3,0,9)
display.set_pixel(0,1,9)
display.set_pixel(2,1,9)
display.set_pixel(4,1,9)
display.set_pixel(1,2,9)
display.set_pixel(3,2,9)
display.set_pixel(0,3,9)
display.set_pixel(2,3,9)
display.set_pixel(4,3,9)
display.set_pixel(1,4,9)
display.set_pixel(3,4,9)
sleep(2000)
print ("display.show(boat, delay = 3000)")
display.show(boat,delay=3000)
print ("display.show(spinner, delay = 50)")
for i in range(5):
display.show(spinner,delay=50)
print ("display.show(flash, delay = 100)")
for i in range (5):
display.show(flash, delay=100)
Le choix
Grove est renommé
Grove Devices (Capteurs Grove). Il permet toujours d'importer les bibliothèques
mb_grove et
mb_pins, et d'activer leurs menus respectifs :
grove (capteurs grove) et
I/O pins (broches entrée/sortie).
Nous nous concentrerons ici sur la seule bibliothèque
mb_grove. Elle permet pour sa part de contrôler des capteurs et actionneurs
Grove connectés à ta carte
micro:bit.
Son menu subit ici une régression par rapport à la version précédente : les broches
pin14 et
pin15 y sont faussement intitulées
pin16, bien que la saisie reste correcte.
C'est pourtant un bug que nous avions
déjà signalé sur une version anglaise précédente, et qui avait été
corrigé.
Puisque le bug revient à l'identique, il faut croire que
Texas Instruments s'est ici mélangé entre les différentes versions des fichiers source...
- Code: Tout sélectionner
from microbit import *
from mb_grove import *
from mb_pins import *
disp_clr()
while not escape():
T = grove.read_temperature(pin0)
print("Temperature = %.1f\u00b0C"%round(T,1))
p = 50
print("Pump On at %.1f"%round(p,1)+"% power")
grove.power(pin8,p)
sleep(2000)
p = 0
print("Pump On at %.1f"%round(p,1)+" % power")
grove.power(pin8,p)
disp_clr()
grove.power(pin8,0)
Le choix
NeoPixel est renommé
NeoPixel and Color (NeoPixel et Couleur). Il permet d'importer la bibliothèque
mb_neopx et d'activer son menu
NeoPixel.
Cette bibliothèque permet de piloter les rubans de diodes adressables à connecter à ta carte
micro:bit.
On peut noter justement l'ajout au menu d'un nouvel onglet
Color, histoire que tu aies directement sous la main de quoi manipuler les couleurs.
Dans l'onglet
Setup (Configuration), nous remarquons la disparition du commentaire indiquant que le rubans ont besoin d'une alimentation externe.
Dans l'onglets
Pins, nous constatons la suppression de la broche
pin8.
- Code: Tout sélectionner
from microbit import *
from mb_neopx import *
from random import *
np = NeoPixel(pin0, 16)
while not escape():
for id in range(len(np)):
red = randint(0,255)
green =randint(0,255)
blue =randint(0,255)
np[id]=(red, green, blue)
np.show()
sleep(100)
np.clear()
Le choix
Input/Output Pins (Broches entrée/sortie) permet d'importer la bibliothèque
mb_pins et d'activer son menu
I/O pins (broches entrée/sortie).
Cette bibliothèque permet de contrôler les broches programmables de ta carte
micro:bit, aussi bien en entrée qu'en sortie, et aussi bien en analogique qu'en digital.
Nous notons ici l'ajout de nouvelles broches au menu :
- Code: Tout sélectionner
from microbit import *
from mb_pins import *
while not escape():
disp_clr()
print("Analog/Digital Input")
print("digital0.read =",pin0.read_digital())
print("digital1.read =",pin1.read_digital())
print("digital2.read =",pin2.read_digital())
print("analog0.read =",pin0.read_analog())
print("analog1.read =",pin1.read_analog())
print("analog2.read =",pin2.read_analog())
sleep(3000)
disp_clr()
print("Analog/Digital Output Test")
print("digital0.write(1)",pin0.write_digital(1))
sleep(1000)
print("digital0.write(0)",pin0.write_digital(0))
sleep(1000)
print("digital1.write(1)",pin1.write_digital(1))
sleep(1000)
print("digital1.write(0)",pin1.write_digital(0))
sleep(1000)
print("digital2.write(1)",pin2.write_digital(1))
sleep(1000)
print("digital2.write(0)",pin2.write_digital(0))
sleep(1000)
print("analog0.write(50)",pin0.write_analog(50))
sleep(1000)
print("analog0.write(0)",pin0.write_analog(0))
sleep(1000)
print("analog1.write(50)",pin1.write_analog(50))
sleep(1000)
print("analog1.write(0)",pin1.write_analog(0))
sleep(1000)
print("analog2.write(50)",pin2.write_analog(50))
sleep(1000)
print("analog2.write(0)",pin2.write_analog(0))
sleep (1000)
Le choix
Sensors est renommé
Sensors and Gestures (Capteurs et gestes). Il permet d'importer la bibliothèque
mb_sensr et d'activer son menu.
Cette bibliothèque permet d'interroger les capteurs intégrés à ta carte
micro:bit.
Un nouvel onglet
Gesture (Geste) nous permet enfin d'interroger directement et facilement les accéléromètre et boussole de la carte au sujet de différents types de
mouvements :
7 types de mouvements/positions sont ici directement au menu :
- up
- down
- left
- right
- face up
- face down
- shake
D'autres mouvements sont également reconnues pas la carte
micro:bit, et tu devrais ici corriger les saisies au clavier alphabétique pour y accéder :
Voici par exemple de quoi interroger et afficher les mouvements en boucle :
- Code: Tout sélectionner
from microbit import *
from mb_sensr import *
while not escape():
print(accelerometer.current_gesture())
#print(accelerometer.is_gesture('face up'))
#print(accelerometer.was_gesture("face down"))
En contrepartie toutefois, nous perdons l'onglet
temperature. Ce n'est pas grave, puisque nous avons vu plus haut que l'appel
temperature() était désormais directement disponible au menu de la bibliothèque
microbit. Et comme déjà dit, c'est peut-être plus logique ainsi, puisque le capteur de température de la
micro:bit est lié au processeur, et contrairement à tous les autres effectue donc une mesure interne, et non une mesure de l'environnement.
Mais que bien que n'étant plus mis en avant au menu, remarquons que
Texas Instruments a pris le soin de laisser l'appel
mb_sensr.temperature() fonctionnel. Ceci garantit ainsi malgré le changement la compatibilité avec les scripts déjà produits !
Le choix
Data Logging (Enregistrement de données) permet d'importer la bibliothèque
mb_log et d'activer son menu.
Cette bibliothèque permet de représenter en direct sous la forme d'un diagramme en ligne brisée, les valeurs retournées par le capteur
micro:bit de ton choix, ou plus généralement par n'importe quel appel
Python.
Voici de suite un exemple interrogeant et traçant en boucle la composante
X de l'accéléromètre :
- Code: Tout sélectionner
from microbit import *
from mb_log import *
from mb_sensr import *
data_log.set_duration(10)
data_log.set_sensor('accelerometer.get_x()')
data_log.set_range(-1200,1200)
data_log.start()
Le choix
Music (Musique) permet d'importer les bibliothèques
mb_music et également désormais
mb_notes, et d'activer leurs menus respectifs :
music (musique) et
notes.
Nous nous concentrerons ici sur la nouveauté : la bibliothèque
mb_notes. Elle permet d'accélérer la saisie de notes au
format micro:bit, pour tes mélodies à jour avec la bibliothèque
mb_music. La saisie clavier te sera ainsi beaucoup plus aisée et rapide !
Les 7 notes de la gamme ainsi que le silence te sont directement accessibles sur les octaves n°1 à 6
(la micro:bit reconnaissant les octaves n°0 à 8), avec par défaut une durée de 4.
Rappelons que notre outil en ligne
midi2calc te permet de convertir tes mélodies au format
MIDI en scripts
Python à jouer avec ta calculatrice sur
micro:bit ou
TI-Innovator Hub.
- Code: Tout sélectionner
from microbit import *
from mb_music import *
notes = ['c4:1', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5', 'c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5','b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5', 'b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5','c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5', 'c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5','c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5', 'c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5','b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5', 'b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5','b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','d3', 'a', 'd4', 'f#', 'c5', 'd4', 'f#', 'c5', 'd3', 'a', 'd4', 'f#', 'c5']
disp_clr()
print("Music and Tone Test")
print("music.play('A4:8')")
music.play('A4:8')
print("music.set_tempo(4,120)")
music.set_tempo(4,120)
print("music.play(music.ODE)")
music.play('music.ODE', wait=True)
print("music.set_tempo(8,360)")
music.set_tempo(8,360)
print("music.play(music.ODE)")
music.play('music.ODE', wait=True)
print("music.pitch(261,1000,wait=True)")
music.pitch(261,1000,wait=True)
print("Play an octave")
for i in range (13):
note = int(440*2**(i/12))
print('note = ',note)
music.pitch(note,500,wait=True)
print("music.set_tempo(4,200)")
music.set_tempo(4,200)
print("music.play(notes)")
music.play(notes, wait=True)
music.set_tempo(4,120)
print("music.play('music.POWER_DOWN')")
music.play('music.POWER_DOWN')
Nous arrivons enfin aux nouveautés concernant la carte
micro:bit v2.
2 choix supplémentaires sont ici au menu de la bibliothèque
microbit :
Audio et
Microphone.
Nous les regarderons bien évidemment plus loin, mais commençons pour le moment par les ajouts apportés aux bibliothèques déjà existantes.
Le choix
Buttons (Boutons) est renommé ici
Buttons and Touch Logo (Boutons et Logo). Il permet d'importer la bibliothèques
mb_butns et d'activer son menu.
Cette bibliothèque se spécialise dans l'interrogation des boutons présents sur la carte
micro:bit :
- bouton A
- bouton B
- et justement, spécificité de la micro:bit v2, bouton tactile sur le logo de la carte
Nous obtenons donc ici un onglet supplémentaire dédié au bouton tactile.
- Code: Tout sélectionner
from microbit import *
from mb_butns import *
while not escape():
disp_clr()
print ("Buttons A and B Test")
print("A.is_pressed",button_a.is_pressed())
print("A.was_pressed",button_a.was_pressed())
print("A.get_presses",button_a.get_presses())
print("B.is_pressed",button_b.is_pressed())
print("B.was_pressed",button_b.was_pressed())
print("b.get_presses",button_b.get_presses())
print("pin_logo.is_touched",pin_logo.is_touched())
sleep(2000)
Le choix
Grove Devices (Capteurs Grove) permet toujours d'importer les bibliothèques
mb_grove et
mb_pins, et d'activer leurs menus respectifs :
grove (capteurs grove) et
I/O pins (broches entrée/sortie).
Nous nous concentrerons ici sur la seule bibliothèque
mb_grove. Elle permet pour sa part de contrôler des capteurs et actionneurs
Grove connectés à ta carte
micro:bit.
Une fonction additionnelle
read_bme280() nous permet ici de récupérer d'un seul coup les 3 mesures retournées par un
capteur BME280, capteur
Grove de pression barométrique, température et humidité.
Le choix
Music (Musique) permet toujours d'importer les bibliothèques
mb_music et
mb_notes, et d'activer leurs menus respectifs :
music (musique) et
notes.
Nous nous concentrerons sur la bibliothèque
mb_music. Elle permet de jouer des notes et donc par extension mélodies, sur le haut parleur directement intégré à la carte
micro:bit v2.
Spécificité donc ici de la
micro:bit v2, nous avons ici au menu une fonction
set_volume() permettant de régler le volume de la sortie audio sur une valeur allant de 0 à 255.
- Code: Tout sélectionner
from microbit import *
from mb_music import *
notes = ['c4:1', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5', 'c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5','b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5', 'b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5','c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5', 'c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5','c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5', 'c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5','b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5', 'b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5','b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','d3', 'a', 'd4', 'f#', 'c5', 'd4', 'f#', 'c5', 'd3', 'a', 'd4', 'f#', 'c5', 'd4', 'f#', 'c5','g3', 'b', 'd4', 'g']
disp_clr()
print("Music and Tone Test")
print("music.play('A4:8')")
music.play('A4:8')
print("music.set_tempo(4,120)")
music.set_tempo(4,120)
print("music.play(music.ODE)")
music.play('music.ODE', wait=True)
print("music.set_tempo(8,360)")
music.set_tempo(8,360)
print("music.play(music.ODE)")
music.play('music.ODE', wait=True)
print("music.pitch(261,1000,wait=True)")
music.pitch(261,1000,wait=True)
print("Play an octave")
for i in range (13):
note = int(440*2**(i/12))
print('note = ',note)
music.pitch(note,500,wait=True)
print("music.set_tempo(4,200)")
music.set_tempo(4,200)
print("music.play(notes)")
music.play(notes, wait=True)
print("Testing volume")
for n in range (0,250,25):
music.set_volume(n)
print (n)
music.pitch(440,500,wait=True)
for n in range (250,0,-25):
music.set_volume(n)
print (n)
music.pitch(440,500,wait=True)
music.set_volume(255)
music.set_tempo(4,120)
print("music.play('music.POWER_DOWN')")
music.play('music.POWER_DOWN')
Le choix
Audio permet d'importer la nouvelle bibliothèque
mb_audio et d'activer son menu.
Cette bibliothèque te permet d'exploiter les nouvelles possibilités de synthèse sonore de la carte
micro:bit v2. En effet cette dernière peut gère bien davantage que de simples notes, tu peux lui faire produire des effets sonores ou même la faire parler.
L'onglet
Sounds (Sons) te donne accès à 10 effets sonores prédéfinis.
- Code: Tout sélectionner
from microbit import *
from mb_audio import *
disp_clr()
print("GIGGLE")
audio.play("Sound.GIGGLE",wait=True,)
sleep(1000)
print("HAPPY")
audio.play("Sound.HAPPY",wait=True,)
sleep(1000)
print("HELLO")
audio.play("Sound.HELLO",wait=True,)
sleep(1000)
print("MYSTERIOUS")
audio.play("Sound.MYSTERIOUS",wait=True,)
sleep(1000)
print("SAD")
audio.play("Sound.SAD",wait=True,)
sleep(1000)
print("SLIDE")
audio.play("Sound.SLIDE",wait=True,)
sleep(1000)
print("SOARING")
audio.play("Sound.SOARING",wait=True,)
sleep(1000)
print("SPRING")
audio.play("Sound.SPRING",wait=True,)
sleep(1000)
print("TWINKLE")
audio.play("Sound.TWINKLE",wait=True,)
sleep(1000)
print("YAWN")
audio.play("Sound.YAWN",wait=True,)
sleep(1000)
Enfin, le choix
Microphone permet d'importer la nouvelle bibliothèque
mb_micro et d'activer son menu.
Cette bibliothèque te permet d'accéder au microphone intégré à la carte
micro:bit v2.
- Code: Tout sélectionner
from microbit import *
from mb_mic import *
microphone.set_threshold(SoundEvent.LOUD,200)
while not escape():
print(microphone.sound_level())
print(microphone.current_event())
print(microphone.is_event(SoundEvent.LOUD))
print(microphone.was_event(SoundEvent.LOUD))
- TI-RunTime :
- 1.0.0 pour BBC microbit v1
- 2.1.0 pour BBC microbit v2
- bibliothèques Python complémentaires :
- 1.0.0 English pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python avec BBC microbit v1
- 2.1.0 English pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python avec BBC microbit v2
- 2.34 Français English pour TI-Nspire CX II avec BBC microbit v1/v2
LogicalJoe vient justement de récupérer une TI-84 Plus CE Python en révision matérielle T, de la démonter et d'en partager une photo. De quoi enfin répondre à nos dernières interrogations.
