11.1 MIDI Entrée

# MIDI Entrée

Dans cette section, nous allons apprendre comment connecter un contrôleur MIDI pour envoyer des événements dans Sonic Pi pour contrôler nos synthés et nos sons. Allez chercher un contrôleur MIDI comme un clavier ou une surface de contrôle et devenons physique !


## Connecter un contrôleur MIDI

Afin d'obtenir des informations de la part d'un périphérique MIDI externe dans Sonic Pi, nous devons d'abord le connecter à notre ordinateur. Le plus souvent, ce sera par une connexion USB, quoi que les vieux équipements auront des connecteurs 5-pins nécessitant que votre ordinateur le supporte physiquement (par exemple, certaines cartes sons internes ont des connecteurs MIDI DIN). Une fois que votre périphérique est connecté, démarrez Sonic Pi et jetez un coup d’œil à la section IO du panneau Préférences. Vous devriez voir le nom de votre périphérique. Si ce n'est pas le cas, essayez de presser le bouton 'Reset MIDI' et regarder s'il apparaît. Si vous ne voyez toujours rien, la prochaine chose à essayer est de consulter la configuration MIDI de votre système d'exploitation pour vérifier si votre périphérique est reconnu. Si tout ça ne marche pas, n'hésitez pas à demander de l'aide sur notre forum amical : https://in-thread.sonic-pi.net

## Recevoir des événements MIDI

Une fois que votre périphérique est connecté, Sonic Pi recevra automatiquement les événements. Vous pouvez le voir par vous-même en manipulation votre périphérique MIDI et en regardant la queue de journalisation dans le secteur inférieur droit de votre fenêtre d'application en-dessous du journal ( si ce n'est pas visible allez dans Préférences->Éditeur->Afficher & Cacher et activer le "Afficher la queue de journalisation"). Vous verrez un flux d'événements comme :

```
/midi:nanokey2_keyboard:0:1/note_off  [55, 64]
/midi:nanokey2_keyboard:0:1/note_on   [53, 102]
/midi:nanokey2_keyboard:0:1/note_off  [57, 64]
/midi:nanokey2_keyboard:0:1/note_off  [53, 64]
/midi:nanokey2_keyboard:0:1/note_on   [57, 87]
/midi:nanokey2_keyboard:0:1/note_on   [55, 81]
/midi:nanokey2_keyboard:0:1/note_on   [53, 96]
/midi:nanokey2_keyboard:0:1/note_off  [55, 64]
```

Une fois que vous pouvez voir un flux de messages comme cela, vous avez connecté avec succès votre périphérique MIDI. Félicitations, voyons ce que nous pouvons faire avec !

## État du Temps MIDI

Ces événements sont divisés en deux sections. Premièrement, il y a le nom de l'événement comme `/midi:nanokey2_keyboard:0:1/note_on`. Deuxièmement, il y a les valeurs de l'événement comme `[18, 62]`. Fait intéressant, ce sont deux choses dont nous avons besoin pour stocker de l'information dans l'État du temps. *Sonic Pi insère automatiquement les événements MIDI entrants dans l'État du Temps*. Cela veut dire que vous pouvez `get` la dernière valeur MIDI et aussi `sync` pour attendre la prochaine valeur MIDI en utilisant tout ce que nous avons appris dans la section 10 de ce tutoriel.

## Code de contrôle

Maintenant que nous avons connecté un périphérique MIDI, vu ses événements dans la queue du journal et découvert que notre connaissance de l'État du Temps est tout ce dont nous avons besoin pour travailler avec les événements, nous pouvons maintenant commencer à avoir du plaisir. Construisons un piano MIDI simple :

```
live_loop :midi_piano do
  note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
  synth :piano, note: note
end
```

Il y a quelques éléments qui se passent dans le code ci-dessus, incluant certains problèmes. Premièrement, nous avons une `live_loop` simple qui se répétera éternellement en exécutant le code entre le bloc `do`/`end`. Cela a été introduit dans la section 9.2. Deuxièmement, nous appelons `sync` pour attendre le prochain événement de l'État du Temps correspondant. Nous utilisons une chaîne de caractères qui représente le message MIDI que nous recherchons (qui est le même que celui affiché dans la queue du journal). Notez que cette longue chaîne de caractères vous est fournie par le système d’auto-complétion de Sonic Pi pour que vous n'ayez pas à la taper en entier manuellement. Dans le journal, nous avons vu qu'il y avait deux valeurs pour chaque événement de note MIDI, donc nous assignons le résultat à deux variables séparées `note` et `velocity`. Finalement, nous déclenchons le synthé `:piano` en passant notre note.

Maintenant, essayez-le. Tapez le code ci-dessus, remplacez la clé de synchronisation avec une chaîne de caractères qui correspond à votre périphérique MIDI spécifique et pressez Exécuter. Hey presto, vous avez un piano qui fonctionne ! Par contre, vous remarquerez probablement quelques problèmes : premièrement, toutes les notes sont au même volume, et ce, peu importe à quelle force vous pressez sur le clavier. Cela peut être réglé facilement en utilisant la valeur de vélocité MIDI et en la convertissant à une amplitude. Étant donné que MIDI a un intervalle de 0->127, pour convertir ce nombre en une valeur entre 0 et 1, nous pouvons simplement le diviser par 127 :

```
live_loop :midi_piano do
  note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
  synth :piano, note: note, amp: velocity / 127.0
end
```

Mettez à jour le code et pressez Exécuter de nouveau. Maintenant la vélocité du clavier est respectée. Ensuite, débarrassons-nous de cette pause casse-pieds.

## Enlever la latence

Avant que nous puissions enlever la pause, nous devons savoir pourquoi elle est là. Dans le but de conserver les synthés et les effets bien synchronisés au travers une variété de processeurs différents, Sonic Pi prévoit l'audio *en avance* de 0.5s par défaut. (Notez que cette latence ajoutée peut être configurée via les fonctions `set_sched_ahead_time!` et `use_sched_ahead_time`). Cette latence de 0.5s est ajoutée à nos déclencheurs de synthé `:piano` puisqu'elle est ajoutée à tous les synthés déclenchés par Sonic Pi. Habituellement, nous voulons réellement cette latence ajoutée puisque cela signifie que tout les synthés seront bien synchronisés. Par contre, cela fait seulement du sens pour les synthés déclenchés par le code en utilisant `play` et `sleep`. Dans ce cas-ci, nous déclenchons le synthé `:piano` avec notre périphérique MIDI externe et nous ne voulons donc pas que Sonic Pi contrôle la synchronisation pour nous. Nous pouvons fermer cette latence avec la commande `use_real_time` ce qui désactive la latence pour le fil d'exécution courant. Cela veut dire que vous pouvez utiliser le mode temps réel pour les boucles en direct qui ont leur synchronisation contrôlée par `sync` avec des périphériques externes, et conserver la latence par défaut pour toutes les autres boucles en direct. Voyons cela de plus près :

```
live_loop :midi_piano do
  use_real_time
  note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
  synth :piano, note: note, amp: velocity / 127.0
end
```

Modifiez votre code pour correspondre avec le code ci-dessus et pressez Exécuter de nouveau. Maintenant, nous avons un piano basse latence avec une vélocité variable codée en seulement 5 lignes. N'était-ce pas facile ?

## Obtenir des valeurs

Finalement, étant donné que nos événements MIDI vont directement dans l'État du Temps, nous pouvons également utiliser la fonction `get` pour récupérer la dernière valeur vue. Cela ne bloque pas le fil d'exécution courant et retourne `nil` s'il n'y a aucune valeur trouvée ( que vous pouvez outrepasser en passant une valeur par défaut - regarder la documentation pour `get`). Rappelez-vous que vous pouvez appeler `get` dans n'importe quel fil d'exécution à n'importe quel moment pour voir la dernière valeur correspondante d'État du Temps. Vous pouvez même utiliser `time_warp` pour retourner dans le temps et appeler `get` pour voir les événements du passé...


## Maintenant vous êtes en contrôle

Le truc génial maintenant est que vous pouvez à présent utiliser les même structures de code pour synchroniser (`sync`) et obtenir (`get`) des information MIDI depuis tout périphérique MIDI et faire tout ce que vous voulez avec ces valeurs. Vous pouvez maintenant choisir ce que votre périphérique MIDI fera !
