Application d`un pattern rythmique sur le jeu d`un guitariste en

PROJET DE L’ATELIER MUSIQUE ET OUTILS INFORMATIQUES
Dispensé par Anne Sedes
Application d’un pattern rythmique sur le jeu d’un
guitariste en utilisant une Wiimote.
Mickaël Le Goff
ATIAM 08/09
SOMMAIRE
I.
Introduction .................................................................................................... 3
II.
La Wiimote en tant que capteur .............................................................. 3
1.
Présentation de la Wiimote ........................................................................... 3
2.
Connexion entre une Wiimote et un ordinateur .......................................... 4
3.
Routage des informations............................................................................. 5
a.
Programmation JAVA .......................................................................................................... 5
b.
Utilisation de GlovePie ........................................................................................................ 6
Réalisation du projet................................................................................ 6
III.
1.
Présentation du projet................................................................................... 6
2.
Choix du signal exploitable........................................................................... 7
3.
Création du patch PureData.......................................................................... 8
4.
a.
Gestion du problème de latence......................................................................................... 8
b.
Description des éléments du patch ................................................................................... 9
c.
Résultats obtenus .............................................................................................................. 12
Améliorations possibles ............................................................................. 13
IV.
Conclusion ................................................................................................ 13
V.
Liste des liens Internet ............................................................................. 14
2
I. Introduction :
Etant guitariste et passionné de jazz, j’ai voulu créer un système permettant de
sortir un pattern rythmique se calant directement sur les accords joués. Il a donc fallu
trouver un capteur permettant de me donner un signal évoluant de la même manière
que celui de la main qui gratte les cordes. Pour ne pas être dérangé par des fils
limitants les déplacements du guitariste, j’ai opté pour la Wiimote en tant que capteur
sans fils. Je décrirais le fonctionnement de cette manette de jeux vidéo, dont
l’utilisation de base a été détournée, dans ce rapport. Ce document va donc
présenter, étape par étape, l’évolution de ce projet ainsi qu’une ouverture sur les
évolutions possibles de ce système afin de l’améliorer. Enfin, une conclusion viendra
clore ce rapport.
II. La Wiimote en tant que capteur :
1. Présentation de la Wiimote :
La Wiimote (contraction de Wii et de remote) est le nom donné au contrôleur de la
console de jeux vidéo « Wii » créée en 2006 par la firme japonaise Nintendo©. Cette
manette à l’avantage d’être sans fil, communiquant avec la console via la technologie
Bluetooth sur une distance pouvant aller jusqu’à dix mètres. Elle est équipée d’une
caméra infra rouge pouvant détecter jusqu’à 4 sources lumineuse en même temps
(pour une utilisation en tant que pointeur) ainsi que de trois accéléromètres qui
détectent les mouvements sur les axes (Ox, Oy et Oz) avec une force s’étendant à
plus ou moins 3g. Les données fournies par ces accéléromètres permettent de
détecter des mouvements de l’utilisateur dans l’espace tels que : la rotation, la
torsion, parcours haut-bas, avant-arrière, gauche-droite (et inversement). Elle est
également dotée de onze boutons poussoirs permettant des contrôles
supplémentaires.
Figure 1 : Différentes vues de la Wiimote
3
Lorsque l’on se sert d’un capteur, il est nécessaire de connaître sa réponse en
fonction des variations de ce que l’on mesure. Ces informations n’étant pas données
par le constructeur, je me suis donc intéressé à des travaux effectués par le
Laboratoire d’Ingénierie des Systèmes Automatisés (LISA) de l’université d’Angers.
Ils ont utilisé la Wiimote pour des expériences mécaniques et ont trouvé que les
capteurs évoluaient, pour les axes Ox et Oy, selon les équations suivantes :
Sur Ox :
v2
− g * cos(α ) −
R
Sur Oy :
− g * sin(α ) +
dv
dt
Pour obtenir ces équations, ils se sont servis de la Wiimote comme pendule avec
v qui correspond à la vitesse de déplacement de la manette, α est l’angle que fait le
pendule avec la verticale et R la longueur du fil du pendule. Nous verrons par la suite
que dans l’utilisation dont nous allons faire de la Wiimote, le mouvement de celle-ci
s’apparentera à celui d’un pendule. Il est intéressant de remarquer que les variations
des accéléromètres en fonction de la vitesse de déplacement de la manette ne sont
pas linéaires et donc les données fournies sont plus difficiles à traiter.
2. Connexion entre une Wiimote et un ordinateur :
La première étape dans l’utilisation d’une Wiimote comme capteur est de pouvoir
connecter celle-ci avec un ordinateur afin de pouvoir récupérer les différentes
informations utiles. Pour se faire, il suffit de disposer d’un récepteur Bluetooth sur
son ordinateur (ou bien connecter une clé USB récepteur Bluetooth) ainsi que le
logiciel BlueSoleil. BlueSoleil détecte et gère les périphériques Bluetooth à proximité
du récepteur. C’est un logiciel payant mais les limitations de la version de
démonstration ne gênent en aucun cas l’utilisation dont nous allons en faire. Le
téléchargement du programme se fait via le site (1).
Une fois le logiciel installé, il suffit d’un double clic, sur le soleil représenté au
milieu de l’interface, pour qu’il détecte tous les dispositifs Bluetooth. Pour que le
logiciel détecte la Wiimote, il faut rester appuyé simultanément sur les boutons
marqués « 1 » et « 2 ». Un icône en forme de joystick avec une ID portant le nom de
Nintendo va apparaître. Une seconde étape consiste à se connecter avec
l’ordinateur. Pour cela il faut cliquer une première fois sur l’icône de la Wiimote
(joystick) puis un double clic sur l’icône en forme de souris en haut de l’interface va
connecter la Wiimote avec l’ordinateur (un lien va apparaître entre le soleil et le
dispositif). Pour que le lien se crée, il faut de nouveau appuyer sur les touches citées
précédemment. Lorsque le lien apparaît, nous pouvons débuter la partie qui consiste
à récupérer les valeurs des différents capteurs.
4
Icône pour connecter le
dispositif
Soleil utilisé
pour la
détection des
périphériques
Icône de la
Wiimote après
détection
Liaison
indiquant
que le
dispositif
est
connecté
Figure 2 : Interface utilisateur de BlueSoleil
3. Routage des informations :
Lorsque nous avons connecté la Wiimote à l’ordinateur, il faut désormais trouver
un moyen d’accéder aux informations des capteurs. Pour cela j’ai eu deux approches
différentes que je vais vous décrire.
a. Programmation JAVA :
Ayant des bases dans ce langage de programmation et ayant trouvé des librairies
spécialement faites pour la gestion d’une Wiimote, j’ai décidé dans un premier temps
d’utiliser le JAVA pour réaliser mon projet. Ce langage de programmation présente
plusieurs avantages. Premièrement il est multi-plateforme, c'est-à-dire qu’une fois
réalisé, le programme peut fonctionner aussi bien sur Windows, Linux ou Mac.
Deuxièmement, il dispose d’une librairie d’origine (java.sound) permettant de gérer
de l’audio au format wave ainsi que tout ce qui concerne les messages Midi.
L’API (librairie) utilisée pour pouvoir gérer la Wiimote est appelée MoteJ et elle
est téléchargeable sur le lien (2). Pour pouvoir l’utiliser il faut également intégrer les
librairies commons.apache et BlueCove dans le projet JAVA (disponibles sur (3) et
(4)). Cet ensemble permet normalement de pouvoir récupérer toutes les informations
envoyées en Bluetooth à l’ordinateur.
Cependant, plusieurs difficultés rencontrées lors de la mise en place du
programme m’ont contraint à abandonner et à opter pour une autre solution,
l’utilisation du logiciel GlovePie.
5
b. Utilisation de GlovePie :
GlovePie est un logiciel gratuit (5) qui a été développé par Carl Kenner. Ce
logiciel est un astucieux programme qui est couramment utilisé dans l'univers du jeu
vidéo pour diriger des informations d'un périphérique (clavier, joystick, autre...) vers
un jeu, en simulant un autre type de périphérique. Il est entre autre doté de fonction
gérant les informations Midi ainsi que celles de la Wiimote. Ainsi, lorsqu’une Wiimote
est connectée via BlueSoleil à l’ordinateur, le langage de programmation
extrêmement simple de GlovePie permet de récupérer puis de router les données
des capteurs. Par exemple, prenons la ligne de code suivante :
midi.c3= wiimote1.A
Cette simple ligne de code permet d’envoyer une NoteOn sur la note Midi C3 (Do 3)
lors d’un appui sur le bouton A de la Wiimote et une NoteOff lorsqu’on relâche le
bouton. GlovePie peut gérer jusqu’à 8 Wiimote simultanément, dans ce cas, il faut
indiquer dans le script le numéro de chaque Wiimote (soit wiimote‘i’ pour la manette
i). Pour connaître toutes les données accessibles de la manette, il suffit de taper
« wiimote » puis lorsque l’on tape un point « . », une liste apparait avec toutes les
variables du contrôleur.
Enfin pour pouvoir router les informations dans d’autres logiciels, j’ai converti
toutes les valeurs reçues en CC Midi que j’envoie dans le logiciel MidiYoke. Ce
logiciel (6) est un pilote de périphérique virtuel qui rend de grands services. Il permet
de réinjecter les messages Midi sortants d'un logiciel vers l'entrée d'un autre. En
clair, il donne la possibilité d'interfacer deux logiciels Midi, même s'il ne sont pas
initialement prévus pour être couplés. Ainsi j’ai pu récupérer et envoyer les
informations de la Wiimote dans le logiciel PureData afin de faire mon projet que je
vais vous décrire.
III.Réalisation du projet :
1. Présentation du projet :
Le projet réalisé est basé sur l’application d’un pattern rythmique qui se cale
sur le jeu d’un guitariste. Il a été spécialement conçu pour pouvoir caler, sur une
série d’accord plaqués sur chaque temps, la rythmique de jazz « Chabada » jouée
normalement par le batteur, principalement sur la ride ou aux balais. Cette rythmique
ajoute du swing à la musique. Voici le pattern, au format Midi, qui va se répéter lors
du jeu du guitariste.
Figure 3 : Pattern rythmique « Chabada »
6
Je me suis donc servi de la Wiimote pour pouvoir capter les mouvements de la
main (ou plutôt de l’avant bras) du guitariste puis j’ai créé un patch sous PureData
afin de créer et caler les samples de batterie sur la guitare rythmique. Je vais donc
vous expliquer les étapes de création de mon patch.
2. Choix du signal exploitable :
Avant de commencer à créer le patch, il a fallu trouver quel était le signal qui
se comportait comme les mouvements du guitariste. Sachant qu’il y a un accord
plaqué sur chaque temps, j’espérais pouvoir trouver un signal périodique, de période
égale au tempo du morceau. J’ai donc créé un premier patch PureData sur lequel je
recevais et affichais dans un graphique (évolution des données en fonction du
temps) les données des accéléromètres sur les 3 axes. Voici le script GlovePie qui
me permettait d’envoyer chaque donnée des accéléromètres sur différents canaux
Midi (ici 100, 101, et 102) :
midi.channel1.ByteControl100 = wiimote1.RawForceX/25
midi.channel1.ByteControl101 = wiimote1.RawForceY/25
midi.channel1.ByteControl102 = wiimote1.RawForceZ/25
Finalement après plusieurs essais de positionnement de la Wiimote sur l’avant
bras ainsi que la visualisation des courbes sur PureData, j’en suis venu à la
conclusion que le signal le plus représentatif des mouvements du guitariste se
trouvaient sur l’axe Oy avec la Wiimote positionnée sur l’avant bras comme sur la
figure suivante.
Figure 4 : position de la Wiimote sur l’avant-bras
En fixant la Wiimote de la sorte, j’ai réussi à obtenir un signal relativement
périodique lors du jeu des accords. Les valeurs données par l’accéléromètre de l’axe
Oy sont proches de zéro lorsque le bras du guitariste est positionné comme sur la
figure 4. Lorsqu’il va descendre son bras, les valeurs vont augmenter, sans pour
autant atteindre la valeur maximale (127) quand le bras est à son plus grand angle
d’inclinaison. Nous pouvons voir sur la figure 5, l’évolution des données du capteurs
en fonction du temps lorsque quelqu’un joue.
7
Figure 5 : Evolution de l’accéléromètre Oy lors du jeu du guitariste
Maintenant que nous avons décidé sur quel signal il était intéressant de
travailler il a fallu mettre en place le patch PureData qui allait ordonnancer les
samples de batterie dans le temps.
3. Création du patch PureData :
a. Gestion du problème de latence :
Sur le pattern rythmique que l’on désire réaliser, on s’aperçoit qu’il y a un coup de
ride sur chaque temps. Une première idée consisterait donc à envoyer le sample à
partir du moment ou la valeur du capteur a dépassé une certaine valeur seuil.
Cependant, si l’on réalise le système de la sorte, les résultats obtenus seront très
mauvais à cause des problèmes de latence. On entendra donc le sample légèrement
décalé par rapport au son de la guitare ce qui rend très difficile le jeu du guitariste et
une impression de décalage constant désagréable à l’oreille des auditeurs.
L’option que j’ai utilisée consiste à détecter le premier accord (au temps t1), puis
le deuxième (au temps t2) et enfin déclencher l’envoi du sample avec un delay égal à
la différence entre les deux temps (t2-t1). Ainsi, en faisant l’hypothèse que le
guitariste ne va pas trop varier de tempo au cours du temps, le sample arrivera au
niveau du troisième accord. Enfin, on répète ce mécanisme entre le deuxième et le
troisième accord pour lancer le sample sur le quatrième accord et ainsi de suite pour
obtenir un sample sur chaque accord joué.
En utilisant ce principe, on peut s’affranchir des problèmes de latence en
déduisant du temps de delay affecté à l’envoi d’un sample, le temps de latence
observé. Il subsiste un inconvénient lié à ce système qui est le fait que la batterie part
seulement à partir du troisième accord et se finit un temps après l’arrêt de jeu du
guitariste. Cependant, ceci est nettement moins problématique que si l’on entendait
tous les samples décalés du tempo de la guitare.
8
b. Description des éléments du patch :
Premièrement je récupère les informations Midi correspondant à celles de
Ce bloc va récupérer les données
l’accéléromètre Oy grâce au bloc :
affectées au contrôle 101 dans MidiYoke (envoyées via GlovePie).
Ces valeurs sont envoyées dans un premier bloc que j’ai appelé « Trigger ». Il a
pour but d’envoyer un seul bang sur chaque front montant du signal dépassant une
valeur seuil que l’utilisateur peut choisir. En effet, selon le type de jeu de chacun, le
seuil nécessaire au déclenchement peut varier. Voici le patch réalisé :
Figure 6 : patch du Trigger
La sortie du Trigger passe ensuite dans un bloc « Switch » qui va sortir un bang
en alternance entre ses deux sorties. Sachant que le bloc Trigger nous donne un
bang à chaque plaquage d’accord, on peut dire que les bangs sortant sur la partie
gauche sont les accords de numéro impair (le premier, le troisième…) et sur la droite,
les accords de chiffre pair (le deuxième, le quatrième…).
9
Figure 7 : patch du Switch
En utilisant le bloc timer pour mesurer l’écart temporel entre 2 bang il faut faire
une sorte d’initialisation du système au niveau du tout premier bang puis basculer sur
un système qui pourra tourner sur chaque bang. Voici un schéma qui décrit le
système :
Figure 8 : système des timers
On s’aperçoit bien que seul le premier bang possède une seule connexion, les
autres étant raccordés de la même manière aux autres timers. J’ai donc créé un
patch init_t1 qui va envoyer sur sa sortie de gauche le premier bang puis tout les
autres sur sa sortie de droite.
Figure 8 : patch de init_t1
10
Finalement, j’effectue la gestion des timers dans le patch WiiDrums, qui va
déclencher les samples de la même manière que la rythmique présentée en figure 3.
J’alterne donc entre un premier envoi d’un sample puis au coup d’après l’envoie de
deux samples avec le deuxième sample ayant un delay équivalent à 0.75 fois le
delay du premier sample. Ainsi on obtient le « Chabada » jazzy en boucle tant que le
guitariste joue ses accords. C’est également dans ce patch qu’est géré la
compensation de la latence du système. Voici le patch WiiDrums qui incorpore tous
les autres sous-patchs.
Figure 9 : patch de WiiDrums
11
Afin que l’utilisation de ce programme soit plus conviviale, j’ai créé un patch
sur lequel on retrouve toute une série de paramètres de réglage du système tel que
la valeur de latence, la valeur du tempo en BPM, le seuil de déclenchement ainsi que
le bang général servant à initialiser le programme (« rosace de la guitare »). Pour
réaliser le patch sans avoir à me servir de la Wiimote en permanence, j’ai créé un
signal en forme de dent de scie (tableau SawTooth) de telle sorte à me générer un
signal de test. Un slider vertical permet de gérer la durée des périodes du signal. Si
le signal test est en marche, il n’est pas possible de se servir du système avec une
Wiimote. Dans ce cas, il faut appuyer sur le message stop et le contrôle revient à
celui de la manette.
Figure 10 : interface de control du système
c. Résultats obtenus :
Un essai a été réalisé et enregistré sous le nom « guitar_and_swing.wave ».
Les résultats obtenus sont très proches de ce qui était attendu. On s’aperçoit que la
batterie se met en marche dès le troisième accord et s’arrête un temps après le
dernier accord joué. Le système réalisé est assez stable pour être utilisé
musicalement. Cependant, la partie la plus difficile à obtenir, est un signal propre en
sortie de la Wiimote ce qui oblige le guitariste à jouer en accentuant le mouvement
de l’avant bras plutôt que celui du poignet ce qui impose une autre technique de jeu.
12
4. Améliorations possibles :
Actuellement le patch sort un pattern rythmique qui se répète tous les deux
temps d’une mesure avec seulement deux samples de ride différents. Ceci
amène une répétition très monotone qui peut être agaçante sur la totalité d’un
morceau. Je propose donc deux solutions pour remédier à ce problème :
•
Lors du mouvement du guitariste, l’accéléromètre de l’axe Oz n’est pas
censé être sollicité. Nos mouvements n’étant pas parfaits, il y aura
toujours une sorte de bruit résiduel (autour de 0) renvoyé par se
capteur. PureData permet de gérer la vitesse de lecture des samples
wave en changeant la fréquence d’échantillonnage. En faisant varier
cette fréquence très légèrement en fonction du bruit du capteur, il sera
possible de changer le timbre des samples. Tant que ceci n’est pas trop
violent, un effet plus naturel va se faire en ayant chaque son de sample
vaguement différent d’un autre.
•
Le pattern rythmique créé par le patch est le rythme de jazz
« Chabada » à son niveau le plus basique. Lors de l’écoute d’un
morceau de jazz, on s’aperçoit que le batteur laisse libre cours à son
imagination pour trouver toute sorte de variations à partir de la
rythmique de base. Il serait donc intéressant d’étudier et d’incorporer
dans le patch toute une série de patterns alternatifs à celui de base et
dont l’envoi se fera ou au hasard ou avec des règles à spécifier (par
exemple, on pourrait ajouter un coup de caisse claire sur le deuxième
temps et demi d’une mesure à 4 temps).
Une autre avancée dans ce projet consisterait à mémoriser des patterns
rythmiques de style de musiques différentes et d’utiliser la dizaine de boutons
présents sur la Wiimote. Ainsi, le guitariste n’aura qu’un bouton à appuyer pour
changer de style rythmique. Ce système pourrait très bien marcher avec une
musique de type reggae ou les « skanks » (accords brefs) sont placés sur les temps
2 et 4 de la mesure, redonnant un signal périodique à la sortie de la Wiimote. Par
contre, il sera beaucoup plus difficile à mettre en place pour de la musique de type
funk dans lesquelles le guitariste joue ses accords de façon très syncopée.
IV. Conclusion :
Nous venons de voir dans ce projet un moyen de récupérer les mouvements d’un
guitariste afin de pouvoir caler une rythmique de batterie sur son jeu et ceci en temps
réel. Le capteur utilisé, la manette Wiimote, permet d’obtenir un grand nombre
d’indications de mouvements ce qui peut être très intéressant pour des travaux de
composition, mélangeant gestuelle et création musicale.
Durant ce projet, j’ai également découvert les capacités du logiciel PureData que
je ne connaissais pas et qui m’a énormément étonné sur ses capacités de création à
partir d’éléments de très bas niveau. La prochaine étape de mon travail se portera
donc sur la mise en place des améliorations citées précédemment afin de rendre à
mon système, une impression moins synthétique.
13
V. Liste des liens Internet :
(1)
http://www.bluesoleil.com
(2)
http://motej.sourceforge.net/download.html
(3)
http://commons.apache.org/downloads/download_logging.cgi
(4)
http://code.google.com/p/bluecove/
(5)
http://carl.kenner.googlepages.com/glovepie_download
(6)
http://www.midiox.com/index.htm?http://www.midiox.com/myoke.htm
14