Dans une
actualité précédente nous lancions
midi2calc, notre service en ligne de conversion de fichiers de partitions
MIDI en scripts
Python pour ta calculatrice.
midi2calc te permettait de donner une toute nouvelle dimension à tes jeux et projets sur ta calculatrice en lui permettant de jouer du son sur un périphérique à connecter, initialement le
TI-Innovator Hub.
Une possibilité offerte à ce jour sur les éditions
Python des
TI-83 Premium CE et
TI-84 Plus CE, ainsi que sur les
TI-Nspire CX II.
Mais ce n'était encore que l'apéritif de la semaine...
Rentrons aujourd'hui dans le cœur du sujet avec une mise à jour majeure de
midi2calc. Tu as désormais le support d'un autre périphérique sonore ayant l'avantage d'être bien plus répandu et abordable, la carte
BBC micro:bit !
Le code produit est compatible aussi bien avec :
- la micro:bit v2 qui dispose directement d'un haut-parleur intégré
- ou la micro:bit v1 à condition de lui connecter un haut-parleur sur le contact 0 comme d'ailleurs illustré en bandeau de l'outil
midi2calc t'offre ici la possibilité de générer ton script pour 2 modules
Python différents au choix :
- soit microbit
- soit ti_innovator (micro:bit) pour les TI-Nspire CX II ou ti_hub (micro:bit) pour la plateforme CE
La différence est très simple. Les modules
microbit sont à installer sur ta calculatrice, liens de téléchargements disponibles en fin d'article. Sans ces modules, le script généré ne fonctionnera pas.
Si par contre tu choisis
ti_innovator (micro:bit) ou
ti_hub (micro:bit), ici tu n'as rien à installer puisque ces modules sont directement intégrés à la calculatrice !
L'astuce mise en œuvre est d'utiliser leur méthode
send() afin de définir notre propre fonction permettant d'envoyer directement à la carte
micro:bit le code
Python que l'on souhaite lui faire exécuter :
- Code: Select all
def send_microbit(cmd):
send("\x04")
send(cmd)
send("\x05")
1) La musique : de la vibration à la partition
Go to topMais commençons rapidement par expliquer tout cela. Au tout début, le son est une vibration mécanique. On appelle fréquence le nombre de vibrations par seconde, que l'on exprime en Hertz
(symbole Hz). Les fréquences audibles par l'oreille humaine vont en gros de
20 Hz à
20000 Hz.
Bien évidemment, les limites de fréquences audibles varient d'une personne à une autre. Donc laissons de côté ces extrêmes, et prenons comme référence une vibration intermédiaire de
440 Hz. Et bien voilà donc notre première note de musique : le
la3 en notation française, ou
A4 en notation anglo-allemande.
Le numéro en suffixe indique l'octave. Un octave est un intervalle de fréquences
$mathjax$\left[f_1,f_2\right[$mathjax$
, où
$mathjax$f_2=2\times f_1$mathjax$
. Ce qui nous permet déjà d'encadrer notre note de référence en passant aux octaves supérieurs
(plus aigus) ou inférieurs
(plus graves) :
- la8 ou A9 ou A8 : 14080 Hz
- la7 ou A8 ou A7 : 7040 Hz
- la6 ou A7 ou A6 : 3520 Hz
- la5 ou A6 ou A5 : 1760 Hz
- la4 ou A5 ou A4 : 880 Hz
- la3 ou A4 ou A3 : 440 Hz
- la2 ou A3 ou A2 : 220 Hz
- la1 ou A2 ou A1 : 110 Hz
- la-1 ou la0 ou A1 ou A0 : 55 Hz
- la-2 ou la-1 ou A0 ou A-1 : 27,5 Hz
- la-3 ou la-2 ou A-1 ou A-2 : 13,75 Hz
Comme tu vois, la numérotation des octaves, c'est compliqué... Il existe diverses numérotations différentes de par le monde. Ci-dessus tu as donc :
- jusqu'à 2 versions de la numérotation latine :
- l'historique, qui n'a pas d'octave de numéro 0, et passe donc directement de l'octave 1 à l'octave -1
- et une où l'octave 0 a été rajouté par soucis de logique
- la numérotation anglo-allemande
- la numérotation de certains instruments compatibles avec la norme MIDI
Sans une connaissance pointue du contexte dans lequel il est énoncé, un numéro d'octave est donc hautement imprécis. Nous éviterons donc soigneusement de faire appel aux numéros d'octaves dans le code qui va suivre.
Séparons chaque octave en 12 sous-intervalles de même longueur que nous appellerons demi-tons. Pour cela nous avons besoin de 11 notes de musique, que voici :
- en notation latine : Do, Do# ou Ré♭, Ré, Ré# ou Mi♭, Mi, Fa, Fa# ou Sol♭, Sol, Sol# ou La♭, La, Si
- en notation anglo-saxonne : C, C# ou D♭, D, D# ou E♭, E, F, F# ou G♭, G, G# ou A♭, A, B
- en notation germanique : C, C# ou D♭, D, D# ou E♭, E, F, F# ou G♭, G, G# ou A♭, A, H
C'est la gamme chromatique. Le rapport entre les fréquences de 2 notes consécutives dans cette gamme est alors de
$mathjax$\sqrt[12]2$mathjax$
.
Maintenant que nous avons les bases, nous pouvons passer aux fichiers
MIDI. Il s'agit d'une version informatisée d'une partition de musique. Elle comprend une ou plusieurs pistes de notes, à jouer chacune par un instrument.
Chaque piste comprend donc des notes à jouer. Chaque note à jouer est décrite par plusieurs caractéristiques, dont entre autres 2 qui vont nous intéresser ici :
- sa hauteur, valeur qui détermine sa fréquence
- sa durée
Le format
MIDI code les hauteurs de notes sur 7 bits, ce qui autorise 2
7=128 notes différentes :
- La note de numéro 0 est la plus grave : selon le contexte le do-3 ou do-2 ou C-1 ou C-2.
- La note de numéro 69 est notre fameux la3 ou A4 ou A3.
- La note de numéro 127 est la plus aiguë : selon le contexte le sol8 ou G9 ou G8.
Ayant récupéré le numéro
n d'une note
MIDI à jouer, il nous est donc très facile de calculer sa fréquence :
$mathjax$440\times {\sqrt[12]2}^{n-69}$mathjax$
.
3) De la partition à la mélodie, une affaire de choix
Go to topLes fichiers
MIDI ont donc été conçus pour gérer plusieurs instruments, et comportent pour cela plusieurs pistes. Il ne sera donc pas rare de rencontrer plusieurs notes devant être jouées en même temps.
Or problème ici, nous contrôlons la BBC micro:bit qui ne peut se comporter que comme 1 seul instrument. Il lui est ainsi impossible de jouer plusieurs notes à la fois.
Nous t'avons justement conçu sur-mesures une interface permettant de résoudre facilement cette difficulté.
Lorsque tu auras fourni ton fichier
MIDI ses différentes pistes te seront listées, chacune avec sa description ainsi que son nombre de notes.
Il te suffit alors de désactiver les pistes correspondant aux instruments d'accompagnement, et de ne garder que la ou les pistes des instruments principaux.
Mais comment donc distinguer les pistes principales ? Une difficulté est qu'il n'y a pas de règle absolue :
- Tu peux regarder les descriptions des pistes : le caractère principal ou accompagnant de la piste sera parfois indiqué, mais pas toujours.
- Tu peux regarder l'ordre des pistes : la ou les pistes principales seront parfois les premières ou les dernières, mais encore une fois pas systématiquement.
- Tu peux regarder le nombre de notes des pistes : un nombre nettement supérieur à ceux des autres pistes peut être un indice, mais il n'est absolument pas infaillible.
Mais justement, ça aussi nous l'avons prévu. Tu trouveras sous la liste des pistes un bouton de lecture, qui te permettra de jouer directement dans ton navigateur ta sélection actuelle de pistes, et ce avec un seul instrument histoire de te donner un aperçu aussi fiable que possible de ce que cela donnera une fois passé sur ta calculatrice.
Tu peux donc immédiatement savoir à l'oreille si tu as effectué une bonne sélection de pistes ou pas !
Tu restes bien sûr libre de conserver plusieurs pistes, et tester l'effet que ça donne. Puisque le cas n'est donc pas à exclure il nous faut faire un choix : en cas de notes devant être jouées en même temps, nous ne conserverons que la plus aiguë sur l'intervalle de temps concerné.
Si les cas où sur un même intervalle de temps une note de piste d'accompagnement est plus aiguë qu'une note de piste principale sont rares, cela pourra donner un bon effet, plus de richesse à ta mélodie.
Notons que si tu disposes de plusieurs
BBC micro:bit, tu peux convertir les pistes séparément et tenter de les jouer simultanément.
4) Fonctions Python disponibles pour jouer du son sur BBC micro:bit
Go to topNous en arrivons donc enfin à la question de la
BBC micro:bit. Comment lui faire jouer un son ?
La méthode
music.pitch(fréquence, durée) permet justement de jouer une fréquence pendant une durée exprimée en millisecondes.
Par exemple pour jouer notre
la3 ou
A4 pendant 1 seconde, on peut appeler
music.pitch(440, 1000).
Précisons de plus que cette méthode
music.pitch() accepte un paramètre nommé optionnel
wait, avec 2 valeurs au choix :
- true : l'appel attendra la fin de la note de musique avant de rendre la main
- false : l'appel rendra immédiatement la main, et ce sera donc à notre code d'attendre le délai nécessaire avant d'envoyer la note suivante
Mais contrairement au
TI-Innovator Hub, la
BBC micro:bit a l'avantage de gérer directement son propre format de mélodie dans le cadre de la méthode
music.play(), ainsi documenté :
- Code: Select all
tune = ["C4:4", "D4:4", "E4:4", "C4:4", "C4:4", "D4:4", "E4:4", "C4:4", "E4:4", "F4:4", "G4:8", "E4:4", "F4:4", "G4:8"]
music.play(tune)
Une liste de chaînes de caractères, c'est bien embêtant niveau consommation de mémoire
heap Python surtout si l'on souhaite jouer de longues mélodies, aussi bien sur calculatrice que sur
micro:bit d'ailleurs.
Nous calculons ici
56+14×(8+49+4)= 910 octets de
heap consommés aussi bien sur la calculatrice que sur la
micro:bit, et tout cela rien que pour les 14 premières notes de
Frère Jacques.
Selon nos tests, on peut toutefois utiliser un tuple à la place d'une liste, et ainsi économiser un petit peu :
- Code: Select all
tune = ("C4:4", "D4:4", "E4:4", "C4:4", "C4:4", "D4:4", "E4:4", "C4:4", "E4:4", "F4:4", "G4:8", "E4:4", "F4:4", "G4:8")
music.play(tune)
On descend à
40+14×(8+49+4)= 894 octets de
heap.
Encore mieux, on peut utiliser des tableaux d'octets
(bytes) au lieu des chaînes pour un gain très significatif :
- Code: Select all
tune = (b"C4:4", b"D4:4", b"E4:4", b"C4:4", b"C4:4", b"D4:4", b"E4:4", b"C4:4", b"E4:4", b"F4:4", b"G4:8", b"E4:4", b"F4:4", b"G4:8")
music.play(tune)
Fantastique, plus que
40+14×(8+33+4)= 670 octets de
heap.
On peut de plus raccourcir encore la chose en ne reprécisant pas les octaves et durées en l'absence de changement :
- Code: Select all
tune = (b"C4:4", b"D", b"E", b"C", b"C", b"D", b"E", b"C", b"E", b"F", b"G:8", b"E:4", b"F", b"G:8")
music.play(tune)
Extraordinaire, plus que
40+14×(8+33)+10×1+3×3+1×4= 637 octets de
heap. Nous avons donc une bonne marge pour limiter la casse induite par ce choix de format pas très malin.
En prime, on pourrait passer la paramètre nommé
wait=false. Cela permettrait ici à notre script de reprendre la main immédiatement après l'envoi de la mélodie, avec donc la possibilité de poursuivre l'exécution de ton jeu ou projet pendant qu'elle joue !
Ce serait vraiment la solution idéale, non ?...
Et bien non, malheureusement nous n'utiliserons pas
music.play().
Ce format nous impose en effet d'envoyer de longues lignes de code
Python, et il semble y avoir un problème avec le protocole de communication entre la calculatrice et la
micro:bit : au-delà des 900 caractères et quelques, les lignes
Python ne semblent pas exécutées par la
micro:bit.
Malheureusement la limite n'est pas fixe. Envoyer 2 lignes légèrement plus courtes génère le même problème, comme si le problème n'était pas la taille de la ligne, mais celle d'un
buffer quelque part...
En attendant de mieux comprendre le problème afin de le contourner, ou d'avoir une mise à jour de
Texas Instruments le corrigeant, nous nous devons donc à grand regret de laisser ce format de côté.
Nous allons utiliser
music.pitch() pour le moment.
Notons que le
TI-Innovator Hub n'intégrait qu'un
buzzer piézoélectrique pas très harmonieux dans les fréquences très graves ou aiguës. La
micro:bit v2 fait bien mieux avec son véritable haut-parleur.
Malgré tout, nous te laissons la possibilité de corriger la hauteur de ta mélodie. Une fois ta sélection de pistes effectuée, l'intervalle de notes utilisées t'est indiqué en numérotation
MIDI. Tu peux alors décaler tout le morceau de musique vers le haut ou vers le bas d'autant de demi-tons que tu voudras.
5) Notre codage Python d'une mélodie
Go to topNous souhaitons te permettre de stocker et jouer de longues mélodies
Python sur ta calculatrice, et ainsi organiser de véritables concerts pour tes jeux ou projets
Python.
Il nous faut minimiser la consommation de mémoire
heap. Comme
déjà expliqué, nous te proposons un format de données compacté sous forme de tableau d'octets
(type bytes). Une note sera codée sur 2 octets :
- 1 octet avec les bits 0 à 6 (7 bits donc) pour indiquer le numéro de note, et le bit 7 pour indiquer un silence
- 2 octets pour indiquer la durée en millisecondes
6) Notre fonction Python pour jouer une mélodie
Go to topEt voilà donc notre fonction jouant la musique, ici dans sa version
TI-83 Premium CE et
TI-84 Plus CE :
- Code: Select all
#the melody playing function
#- mus : melody data
#- durat_bytes : number of bytes encoding each note duration
def play_melody_on_microbit(mus, durat_bytes):
r = 2 ** (1 / 12)
t2, durat, i = monotonic(), 0, 0
t1 = t2
while i < len(mus):
t1, t2 = t2, monotonic()
deltat = max(0, (t2 - t1) / 1000 - durat)
note = mus[i]
i += note < 0x80
durat = mus[i] & ((note ^ 0x80) | 0x7F)
i += 1
if durat_bytes > 1:
durat |= int.from_bytes(mus[i:i + durat_bytes - 1],'little') << (8 - (note >= 0x80))
i += durat_bytes - 1
durat = max(1, durat) / 1000
music.pitch(round((note < 0x80) and 440 * r**(note - 57)), int(durat*1000), wait=False)
sleep(max(0, durat - deltat))
Chaque appel
music.pitch(note, durée) est ici suivi d'un appel
time.sleep(durée) afin d'attendre avant de jouer la note suivante.
Toutefois pour enchaîner correctement les notes de musique et tenir le rythme, il nous faut tenir compte du temps de latence dû au fait que l'appel sound.tone() est ici converti en une commande envoyée à la micro:bit par le port USB de la calculatrice, ainsi que du temps d'exécution que nécessite tout le reste du corps de la boucle.
Et bien c'est prévu, la méthode
time.monotonic() ou
time.ticks_ms() est utilisée pour mesurer la durée d'exécution d'une itération, prise en compte pour corriger l'appel
time.sleep() de l'itération suivante.
Une fois ta conversion validée, tu obtiens ton script
Python converti sous deux formes différentes :
- un fichier .py téléchargeable
- un code en coloration syntaxique que tu peux directement sélectionner et copier-coller
Voyons tout-de-suite ce que ça donne. Nous t'avions promis de quoi jouer des mélodies ambitieuses pour tes jeux ou projets, voici par exemple de quoi te montrer que ça tient bien le rythme, avec l'air de la chevauchée des Walkyries par
Richard Wagner, 1856 :
De plus nous t'avons donc dit plus haut que le haut-parleur de la
micro:bit v2 se comportait bien mieux que le
buzzer du
TI-Innovator Hub, notamment dans les aigus. Voici de quoi t'en convaincre avec rien de moins que l'un des airs les plus virtuoses de l'art lyrique culminant au
Fa5 ou
F6, l'air de la Reine de la nuit dans
La Flûte enchantée de
Wolfgang Amadeus Mozart, 1791 :
by 
Aujourd'hui, voici non pas un mais 5 labyrinthes par notre cher _Orlando_ : Laby I, Laby II, Laby III, Laby IV et Laby V.
