# 1 - Cher ami, bienvenue :-)

Bienvenue dans Sonic Pi. J’espère que vous êtes aussi enthousiasmé à l’idée de commencer à créer vos propres sons délirants que je le suis. Ce sera un parcours vraiment amusant où vous allez tout apprendre de la musique, de la synthèse, de la programmation, de la composition, de l’interprétation et plus encore.

Mais attendez, comme je suis impoli ! Je me présente, je suis Sam Aaron, le gars qui a créé Sonic Pi. Vous pouvez me trouver sur Twitter à @samaaron et je serai plus qu’heureux de vous saluer. Vous pourriez aussi être intéressé par mes performances de « Live Coding » où je progamme en direct avec Sonic Pi devant un public.

Si vous avez des observations ou des idées pour améliorer Sonic Pi, faites m’en part s’il vous plaît, les retours sont tellement utiles. On ne sait jamais, votre idée pourrait être la prochaine fonctionnalité importante !

Ce didacticiel est divisé en sections groupées par catégories. Même si je l’ai écrit pour avoir une progression d’apprentissage facile du début jusqu’à la fin, sentez-vous vraiment libre de plonger dans l’une ou l’autre section comme cela vous convient. Si vous pensez qu’il manque quelque chose, n’hésitez pas à me le faire savoir et j’y penserai pour une prochaine version.

Enfin, regarder d’autres faire du live-coding est une excellente façon d’apprendre, je diffuse régulièrement des lives sur http://youtube.com/samaaron, n’hésitez pas à me rendre visite pour un bonjour ou pour me poser des questions :-)

OK, démarrons…

# 1.1 - Programmation interactive (Live Coding)

Un des aspects les plus passionnants de Sonic Pi est qu’il vous permet d’écrire et de modifier du code en “live” pour faire de la musique, comme on peut le faire avec une guitare par exemple. Cela veut dire qu’avec un peu de pratique, vous pourrez jouer avec Sonic Pi sur scène et vous amuser avec.

## Libérez votre créativité

Avant que vous ne plongiez dans les détails réels du fonctionnement de Sonic Pi dans la suite de ce tutoriel, j’aimerais vous faire vivre l’expérience de à quoi ça ressemble de coder en “live”. Ne vous inquiétez pas si vous ne comprenez pas beaucoup ou rien de ceci. Essayez juste de rester assis sur votre siège et de profiter…

## Une boucle live

Commençons, copiez le code suivant dans un “buffer” libre :

    live_loop :flibble do
      sample :bd_haus, rate: 1
      sleep 0.5
    end

Maintenant, appuyez sur le bouton `Run` et vous entendrez un joli battement de grosse caisse. Si vous souhaitez arrêter le son à un moment quelconque, pressez simplement le bouton `Stop`. Mais pas tout de suite… suivez ces instructions plutôt :

1. Assurez-vous que le son de la grosse caisse est encore présent
2. Changez la valeur de `sleep` de `0.5` à quelque chose de plus élevé comme `1`.
3. Pressez à nouveau le bouton `Run`
4. Remarquez le changement de vitesse de la batterie.
5. Finalement, rappelez-vous de cet instant, c’est la première fois que vous avez codé en “live” avec Sonic Pi et ce n’est certainement pas la dernière…

Ok, c’était assez simple. Ajoutons quelque chose au mixage. Au dessus de `sample :bd_haus` ajoutez la ligne `sample :ambi_choir, rate: 0.3`. Votre code devrait ressembler à ceci :

    live_loop :flibble do
      sample :ambi_choir, rate: 0.3
      sample :bd_haus, rate: 1
      sleep 1
    end

Maintenant, amusez-vous à modifier le code. Changez la valeur du `rate` - Que se passe-t-il lorsque vous utilisez des grandes valeurs , des petites ou même des négatives ? Regardez ce qui se passe quand vous changez légèrement la valeur de `rate:` pour l’échantillon `:ambi_choir` (disons 0.29). Que se passe-t-il lorsque vous choisissez une valeur vraiment petite de `sleep` ? Regardez si vous arrivez à le faire aller tellement vite que votre ordinateur s’arrêtera avec une erreur parce qu’il ne peut plus continuer comme cela (si cela arrive, choisissez juste une durée `sleep` plus grande et pressez `Run` à nouveau).

Essayez de commenter une des lignes `sample` en ajoutant un `#` au début :

    live_loop :flibble do
      sample :ambi_choir, rate: 0.3
    #  sample :bd_haus, rate: 1
      sleep 1
    end

Remarquez comment cela indique à l’ordinateur de l’ignorer, ainsi nous ne l’entendons pas. On appelle ça un commentaire. Dans Sonic Pi, nous pouvons utilisez des commentaires pour enlever ou ajouter des choses au mixage.

Finalement, je vous laisse avec quelque chose de sympa à jouer. Prenez le code ci-dessous et copiez-le dans un autre “buffer”. Maintenant n’essayez pas trop de le comprendre, remarquez juste qu’il y a deux boucles - ainsi deux choses marchent en même temps. Maintenant, faites ce que vous faites le mieux : expérimentez et jouez. Voici quelques suggestions :

- Essayez de modifier les valeurs en bleu du `rate:` pour entendre comme le son de l’échantillon change.
- Essayez de changer les durées de `sleep` et découvrez que les deux boucles peuvent tourner à différentes cadences.
- Essayez de décommenter la ligne “sample” (enlevez le `#`) et appréciez le son de la guitare joué à l’envers.
- Essayez de changer une des valeurs en bleu de `mix:` avec des nombres entre `0` (pas dans le mixage) et `1` (entièrement dans le mixage).

Rappelez-vous de presser `Run` et vous entendrez le changement la fois suivante où la boucle tournera. Si vous êtes dans le pétrin, ne vous inquiétez pas : pressez `Stop`, effacez le code dans le “buffer”, collez une copie originale et vous serez prêt à improviser à nouveau. C’est en faisant des fautes que vous apprendrez le plus vite…

    live_loop :guit do
      with_fx :echo, mix: 0.3, phase: 0.25 do
        sample :guit_em9, rate: 0.5
      end
    #  sample :guit_em9, rate: -0.5
      sleep 8
    end
    live_loop :boom do
      with_fx :reverb, room: 1 do
        sample :bd_boom, amp: 10, rate: 1
      end
      sleep 8
    end

Maintenant, continuez à jouer et à expérimenter jusqu’à ce que votre curiosité s’avive réellement et vous commencerez à vous demander ce que vous pouvez faire d’autre. Vous êtes maintenant prêt à lire le reste du tutoriel.

Alors, qu’attendez-vous…

# 1.2 - L’Interface de Sonic Pi

Sonic Pi a une interface très simple pour coder de la musique. Passons un peu de temps à l’explorer.

- A - Contrôles de jeu
- B - Contrôles d’édition
- C - Info et aide
- D - Éditeur de code
- E - Panneau des préférences
- F - Visualisateur de la trace
- G - Système d’aide
- H - Visualisateur de la portée
- F - Visualiseur des Signaux (Cue)

## A. Contrôles de jeu

Ces boutons roses sont les principaux contrôles pour démarrer et arrêter les sons. Il y a le bouton Run pour exécuter le code présent dans l’éditeur, Stop pour arrêter tous les codes en cours d’exécution, Save pour sauvegarder le code dans un fichier externe et Record pour créer un enregistrement du son (un fichier WAV) en cours de jeu.

## B. Contrôles d’édition

Ces boutons orange vous permettent de manipuler l’éditeur de code. Les boutons Taille + et Taille - vous permettent de rendre le texte plus grand et plus petit.

## C. Info et Aide

Ces boutons bleus vous donnent accès à l’information, à l’aide et aux préférences. Le bouton Info ouvre la fenêtre d’information qui contient de l’information sur Sonic Pi lui-même - le noyau de l’équipe, l’historique, les contributeurs, et la communauté. Le bouton Aide active le système d’aide (G) et le bouton Prefs active la fenêtre des préférences qui vous permet de contrôler quelques paramètres systèmes basiques.

## D. Éditeur de code

C’est la zone dans laquelle vous écrirez votre code et composerez / interpréterez de la musique. C’est un simple éditeur de texte où vous pourrez écrire votre code, l’effacer, couper et coller, etc. Voyez-le comme une version très basique de Word ou de Google Docs. L’éditeur coloriera automatiquement les mots selon leur signification dans le code. Ceci peut paraître étrange au début, mais vous trouverez vite cela très utile. Par exemple, vous saurez que quelque chose est un nombre parce qu’il sera bleu.

## E. Panneau des préférences

Sonic Pi supporte quelques préférences ajustables auxquelles on peut accéder en pressant le bouton Prefs à droite des boutons Info et Help. Cela activera l’affichage du panneau des préférences qui inclut un nombre d’options modifiables. Par exemple pour forcer le mode mono, inverser la stéréo, activer le mode verbeux de la trace et aussi régler un curseur de volume et le sélecteur audio du Raspberry Pi.

## F. Visualisateur de la trace

Quand vous exécutez votre code, l’information sur ce que le programme est en train de faire est affichée dans le visualiseur de la trace. Par défaut, vous verrez un message pour chaque son que vous créez avec l’heure exacte à laquelle le son a été déclenché. C’est très utile pour déboguer votre code et comprendre ce qu’il fait.

## G. Système d’aide

Enfin, un des aspects les plus importants de l’interface de Sonic Pi est le système d’aide qui apparaît au bas de la fenêtre. Il peut être activé ou désactivé en cliquant sur le bouton Help bleu. Le système d’aide contient de l’aide et de l’information sur tous les aspects de Sonic Pi, y compris ce tutoriel, une liste des synthétiseurs, des échantillons (“samples”), des exemples, des effets (“FX”) disponibles, et une liste complète de toutes les fonctions que Sonic Pi fournit pour coder de la musique.

## H. Visualiseur de la portée

Le visualiseur d’oscillo vous permet de voir le son que vous entendez. Vous pouvez facilement voir que l’onde en dent de scie ressemble à une scie et que le bip basique est une onde sinusoïdale courbe. Vous pouvez voir aussi la différence entre les sons forts et légers à la taille des lignes. Il y a 3 oscilloscopes avec lesquels jouer - celui par défaut est un oscilloscope combiné pour les canaux gauche et droit, il y a un oscilloscope stéréo qui affiche un graphique différent pour chaque canal. Enfin, il y a l’oscilloscope Lissajous qui montre la relation de phase entre les canaux gauche et droit et vous permet de faire de jolis dessins avec du son (https://en.wikipedia.org/wiki/Lissajous_curve).

## I. Visualiseur de signal (cue)

Tous les événements internes et externes (appelés cues dans Sonic Pi) sont automatiquement enregistrés dans le Cue Viewer. Par exemple, si vous avez un contrôleur MIDI connecté et que vous appuyez sur l’un de ses boutons, vous verrez un nouvel événement dans le Cue Viewer vous indiquant le nom du contrôleur et le bouton sur lequel vous avez appuyé. Une fois que vous aurez maîtrisé les bases de la création et de la production de sons, vous commencerez à vouloir marquer des sons ou des sections entières de sons en fonction d’événements tels que ceux-ci. Un signal sonore n’est qu’une indication que quelque chose s’est produit. Par exemple, chaque fois qu’une boucle en direct tourne, elle envoie un signal qui est enregistré dans le Cue Viewer. De plus, des événements externes tels que des messages MIDI provenant d’un équipement MIDI connecté et des messages OSC provenant d’autres programmes ou ordinateurs sont également affichés dans le Cue Viewer. Il est également possible de générer directement des événements de cue en utilisant la fonction “rescue”. Tout ce qui apparaît dans le Cue Viewer peut être utilisé pour déclencher un événement. Ce point est traité plus en détail dans les sections 10 à 12 de ce tutoriel.

# 1.3 - Apprendre en jouant

Sonic Pi vous encourage à en apprendre à la fois sur la programmation et sur la musique au travers du jeu et de l’expérimentation. La plus importante chose est que vous vous amusiez, et avant que vous vous en rendiez compte, vous aurez appris comment coder, composer et interpréter sans le faire exprès.

## Il n’y a pas de fautes

Alors que nous abordons ce sujet, laissez-moi vous donner un petit conseil que j’ai appris pendant des années à coder de la musique en “live” : il n’y a pas de fautes, seulement des opportunités. C’est ce que j’ai souvent entendu à propos du jazz mais cela fonctionne aussi avec le codage en “live”. Peu importe votre niveau d’expérience - du débutant complet jusqu’à “l’algoraver” (codeur de musique) chevronné, vous exécuterez un jour un code qui aura un résultat totalement inattendu. Cela pourrait sonner extrêmement “cool” : auquel cas continuez avec. Toutefois, cela pourrait aussi sonner discordant et à côté de la plaque. Peu importe ce qui se passe - ce qui importe est ce que vous allez faire avec ensuite. Prenez le son, manipulez-le et transformez-le en quelque chose de génial. Le public deviendra déchaîné.

## Commencez simple

Quand vous apprenez, il est tentant de vouloir faire des choses géniales immédiatement. Cependant, conservez cette idée et voyez-la comme un but distant à atteindre plus tard. Pour l’instant, pensez à la chose la plus simple que vous pourriez écrire qui serait amusante et gratifiante, c’est un petit pas vers la chose géniale que vous avez en tête. Une fois que vous avez une idée pour cette étape simple, essayez de la construire, jouez avec et voyez quelles nouvelles idées cela vous donne. Sous peu, vous serez trop occupé à vous amuser et à faire de réels progrès.

Assurez-vous simplement de partager votre travail avec les autres !

# 2 - Synthétiseurs

OK, assez d’introduction, plongeons dans les sons.

Dans cette section, nous allons couvrir les bases du déclenchement et de la manipulation des synthés. “Synthé” est l’abréviation de synthétiseur, qui est un mot savant pour quelque chose qui crée des sons. Typiquement, les synthétiseurs sont assez compliqués à utiliser - particulièrement les synthés analogiques comme les modules Eurorack qui sont connectés ensemble par un fouilli de fils. Toutefois, Sonic Pi vous offre beaucoup de cette puissance d’une manière très simple et abordable.

Ne soyez pas dupé par la simplicité apparente de l’interface de Sonic Pi. Vous pouvez aller très en profondeur dans une manipulation très sophistiquée des sons si c’est votre dada. Tenez bien vos chapeaux…

# 2.1 - Vos premiers Beeps

Jetez un œil sur le code suivant :

    play 70

C’est là que tout commence. Allez de l’avant, copiez et collez-le dans la fenêtre de code en haut de l’application (le grand espace blanc en dessous du bouton Exécuter). Maintenant, pressez Exécuter…

## Beep !

Intense. Appuyez encore une fois. Et encore. Et encore…

Waouh, c’est fou ! Je suis sûr que vous pourriez continuer à faire cela toute la journée. Mais attendez, avant que vous ne vous perdiez dans un flot infini de bips, essayez de changer le nombre :

    play 75

Entendez-vous la différence ? Essayez un nombre plus petit :

    play 60

Ainsi, les petits nombres font des bips plus graves et les nombres les plus élevés font des bips plus aigus. Tout comme sur un piano, les touches de la partie inférieure du piano (côté gauche) jouent les notes graves et les touches de la partie supérieure du piano (côté droit) jouent les notes aiguës.

Il s’avère que le Do de la quatrième octave (C en notation anglaise) est identifié par le nombre 60. `play 60` joue donc le Do de la 4ème octave. Pour jouer la touche suivante vers la droite sur un piano, vous devez ajouter 1 à 60 et donc tapez `play 61`, qui correspond alors à la touche noire du Do dièse. Pour jouer le Ré, la prochaine touche à droite, on ajoute 1 donc `play 62`.

Ne vous inquiétez pas si cela ne signifie rien pour vous - c’était le cas pour moi au début quand j’ai commencé. Tout ce qui importe pour le moment est que vous sachiez que les petits nombres font des beeps graves et que les grands nombres font des beeps aigus.

## Accords

Jouer une note est assez plaisant, mais en jouer plusieurs en même temps est encore mieux. Essayez-le :

    play 72
    play 75
    play 79

Jazzy ! Ainsi quand vous écrivez plusieurs `play`s, ils sont tous joués en même temps. Essayez-le vous-même : quels sont les nombres qui sonnent bien ensemble ? Lesquels sonnent terrible ? Expérimentez, explorez et trouvez ce qui sonne bien pour vous.

## Mélodie

Ainsi, jouer des notes et des accords est plaisant - mais comment jouer une mélodie ? Que faire si vous voulez jouer une note après une autre et pas en même temps ? Eh bien, c’est facile, vous avez juste besoin de `sleep` entre les notes :

    play 72
    sleep 1
    play 75
    sleep 1
    play 79

Comme c’est charmant, un petit arpège. Alors que signifie le `1` dans `sleep 1` ? Eh bien, cela représente la durée du sleep. Ça signifie réellement “dors pendant un temps musical”, mais pour l’instant nous pouvons penser qu’il s’agit de dormir pendant 1 seconde. Alors que faire si nous voulons que notre arpège soit un peu plus rapide ? Eh bien, nous devons utiliser des valeurs de sleep plus petites. Pourquoi pas la moitié, c’est-à-dire `0.5` :

    play 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

Remarquez comment ça joue plus rapidement. Maintenant, essayez vous-même, changez les durées - utilisez différentes durées et différentes notes.

Une chose à essayer est les notes intermédiaires comme `play 52.3` et `play 52.63`. Il n’est absolument pas nécessaire de coller aux notes standardisées. Jouez et faites-vous plaisir.

## Les noms classiques des notes

Ceux qui connaissent déjà la notation musicale (ne vous inquiétez pas si ce n’est pas votre cas : vous n’en n’avez pas besoin pour vous amuser) pourraient aimer écrire une mélodie en utilisant les noms des notes comme “Do” ou “Fa#” plutôt que des nombres. Sonic Pi a ce qu’il faut, mais en notation anglaise (`A` pour “La”, `B` pour “Si”, `C` pour “Do”, `D` pour “Ré”, `E` pour “Mi”, `F` pour “Fa”, `G` pour “Sol”). Vous pouvez faire la chose suivante :

    play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E

Notez de mettre des deux-points `:` devant votre nom de note de manière qu’elle apparaisse en rose. Vous pouvez également spécifier l’octave en ajoutant un nombre derrière le nom de la note :

    play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4

Si vous voulez jouer un dièse, ajoutez un `s` (pour “sharp”) derrière le nom de la note, comme `play :Fs3` et si vous voulez jouer un bémol, ajoutez un `b` (pour bemol) comme `play :Eb3`.

Il y a aussi un raccourci pratique pour un repos (une façon musicale de dire de ne rien jouer à la place d’une note) en utilisant `:r`, `:rest` ou `nil`.

Maintenant défoulez-vous et faites-vous plaisir en faisant vos propres morceaux.

# 2.2 - Paramètres des synthés : Amp et Pan

De la même manière qu’il vous permet de contrôler chaque note ou chaque échantillon à jouer, Sonic Pi fournit un large éventail d’options pour confectionner ou contrôler les sons. Nous couvrirons beaucoup d’entre eux dans ce tutoriel et il y a une documentation exhaustive pour chacun d’eux dans le système d’aide. Toutefois pour l’instant, nous allons introduire deux des plus utiles : amplitude et pan. Regardons en premier ce que les options sont réellement.

## Options

Sonic Pi supporte la notion d’options pour ses synthés. Les options sont des informations de contrôle que vous indiquez à `play` et qui modifient et contrôlent les aspects du son que vous entendez. Chaque synthé a son propre jeu d’options pour ajuster finement ses sons. Cependant, il y a un ensemble commun d’options partagé par beaucoup de sons comme `amp:` et les options d’enveloppe (couvertes dans une autre section).

Les options ont deux parties principales, leur nom (le nom du contrôle) et leur valeur (la valeur que vous voulez affecter au contrôle). Par exemple, vous pourriez avoir une option appelée `cheese:` et vouloir lui affecter la valeur `1`.

Les options sont passées aux appels à `play` en utilisant une virgule `,` et ensuite le nom de l’option comme `amp:` (n’oubliez pas les deux-points `:`) et ensuite un espace et la valeur de l’option. Par exemple :

    play 50, cheese: 1

(Notez que `cheese:` n’est pas une option valide, elle est juste utilisée pour l’exemple).

Vous pouvez passer plusieurs options en les séparant par une virgule :

    play 50, cheese: 1, beans: 0.5

L’ordre des options n’est pas imposé, ainsi, ce qui suit est identique :

    play 50, beans: 0.5, cheese: 1

Les options qui ne sont pas reconnues par le synthé sont simplement ignorées (comme `cheese` et `beans` qui sont clairement des noms de paramètres ridicules !)

Si vous utilisez accidentellement 2 fois la même option avec des valeurs différentes, la dernière gagne. Par exemple, `beans:` aura ici la valeur 2 plutôt que 0.5 :

    play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2

Beaucoup de choses dans Sonic Pi acceptent des options, aussi passez un peu de temps à apprendre comment les utiliser et vous serez au point ! Jouons avec notre première option : `amp:`.

## Amplitude

L’amplitude est la représentation informatique du volume d’un son. Une amplitude élevée produit un son fort et une amplitude basse produit un son faible. A la manière dont Sonic Pi utilise des nombres pour représenter les durées et les notes, des nombres sont aussi utilisés pour représenter l’amplitude. Une amplitude 0 est le silence (vous n’entendez rien) tandis qu’une amplitude de 1 désigne le volume normal. Vous pouvez même monter l’amplitude à 2, 10, 100. Toutefois, vous devez noter que lorsque l’amplitude globale de tous les sons devient trop élevée, Sonic Pi utilise ce qui est appelé un compresseur pour l’aplatir, de manière à s’assurer que le volume ne soit pas trop fort pour vos oreilles. Cela peut fréquemment rendre le son distordu et étrange. Aussi essayez d’utiliser des amplitudes basses, c’est-à-dire dans l’intervalle 0 à 0.5 pour éviter la compression.

## Amp-ez le

Pour changer l’amplitude d’un son, vous pouvez utiliser l’option `amp:`. Par exemple, pour jouer à amplitude moitié, passez 0.5 :

    play 60, amp: 0.5

Pour doubler l’amplitude, passez 2 :

    play 60, amp: 2

L’option `amp:` ne modifie que l’appel au `play` auquel il est associé. Aussi, dans l’exemple suivant, le premier appel à play est à moitié volume et le second revient à la valeur par défaut (1) :

    play 60, amp: 0.5
    sleep 0.5
    play 65

Bien entendu, vous pouvez utiliser différentes valeurs de `amp:` pour chaque appel à play :

    play 50, amp: 0.1
    sleep 0.25
    play 55, amp: 0.2
    sleep 0.25
    play 57, amp: 0.4
    sleep 0.25
    play 62, amp: 1

## Balance stéréo

Une autre option agréable à utiliser est `pan:` qui contrôle la balance du son en stéréo. Balancer un son vers la gauche signifie que votre oreille va l’entendre sortir du haut-parleur de gauche, et le balancer vers la droite que vous l’entendrez sortir par le haut-parleur de droite. Pour nos valeurs, nous utilisons -1 pour représenter complètement à gauche, 0 pour représenter le centre et 1 pour représenter complètement à droite dans le champ stéréo. Bien entendu, vous êtes libre d’utiliser toute valeur entre -1 et 1 pour contrôler le positionnement précis de votre son.

Jouons un beep à destination du haut-parleur de gauche :

    play 60, pan: -1

Maintenant, jouons-le à destination du haut-parleur de droite :

    play 60, pan: 1

Finalement, jouons-le à destination du centre des deux (la position par défaut) :

    play 60, pan: 0

Maintenant, allez et prenez plaisir à changer l’amplitude et la balance de vos sons !

# 2.3 - Changement de synthés

Jusqu’à maintenant, nous nous sommes bien amusés à faire des beeps. Cependant, vous commencez probablement à être fatigué par le bruit basique du beep. Sonic Pi ne peut pas m’en offrir plus ? Il y a certainement plus dans le codage en “live” que de jouer seulement des beeps ? Oui, et dans cette section, nous allons explorer l’étendue des sons que Sonic Pi vous propose.

## Synthétiseurs

Sonic Pi dispose d’instruments appelés synthés (raccourci pour synthétiseurs). Tandis que les échantillons (samples) représentent des sons pré-enregistrés, les synthés (synths) sont capables de générer des nouveaux sons en fonction de la façon dont vous les contrôlez (ce que nous explorerons plus tard dans ce tutoriel). Les synthés de Sonic Pi sont très puissants et expressifs, et vous prendrez du plaisir à les explorer et jouer avec. Avant tout, apprenons à sélectionner le synthé qui sera utilisé.

## Dents de scie vibrantes et prophètes

Un son sympathique est l’onde en dent de scie (saw). Essayons-le :

    use_synth :saw
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    play 62

Essayons un autre son, le prophet :

    use_synth :prophet
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    play 62

Et si on combinait deux sons ? D’abord l’un après l’autre :

    use_synth :saw
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    use_synth :prophet
    play 57

Maintenant plusieurs sons en même temps (en ne mettant pas d’instructions `sleep` entre les `play` successifs) :

    use_synth :tb303
    play 38
    use_synth :dsaw
    play 50
    use_synth :prophet
    play 57

Notez que la commande `use_synth` n’agit que sur les appels suivants à `play`. Pensez à elle comme un gros commutateur : les nouveaux appels à `play` vont jouer tout synthé qui est désigné “en cours”. Vous pouvez enclencher le commutateur sur un nouveau synthé avec `use_synth`.

## Découverte des synthés

Pour lister les synthés que Sonic Pi propose, jetez un œil sur les options de Synths dans le menu horizontal tout à fait en bas (à gauche de Fx). Il y en a plus de 20 au choix. Voici mes préférés :

- `:prophet`
- `:dsaw`
- `:fm`
- `:tb303`
- `:pulse`

Maintenant jouez en commutant les synthés au cours de votre jeu. Prenez plaisir à combiner des synthés pour faire de nouveaux sons et aussi en utilisant différents synthés selon les sections de votre musique.

# 2.4 - Durées avec enveloppes

Dans une section précédente, nous avons vu comment nous pouvions utiliser la commande sleep pour contrôler le moment du déclenchement de nos sons. Toutefois, nous n’avons pas encore été capables de contrôler la durée des sons.

Dans le but de nous offrir des moyens simples mais puissants de contrôle de durée de nos sons, Sonic Pi fournit la technique d’enveloppe d’amplitude ADSR (nous expliquerons ce que ADSR signifie plus loin dans cette section). Une enveloppe d’amplitude offre deux moyens utiles de contrôle :

- contrôle sur la durée d’un son
- contrôle sur l’amplitude d’un son

## Durée

La durée est le temps pendant lequel le son se maintient. Une longue durée signifie que vous entendez le son plus longtemps. Les sons de Sonic Pi ont tous une enveloppe d’amplitude, et la durée totale de cette enveloppe est la durée du son. Ainsi, en contrôlant l’enveloppe, vous contrôlez la durée.

## Amplitude

L’enveloppe ADSR non seulement contrôle la durée, mais vous donne aussi un contrôle fin sur l’amplitude du son. Tous les sons commencent et finissent par le silence, avec une part non silencieuse entre. Les enveloppes vous permettent de faire évoluer ou de maintenir l’amplitude des parties non-silencieuses du son. C’est comme si vous donniez à quelqu’un des instructions sur comment augmenter ou diminuer le volume d’un ampli de guitare. Par exemple, vous pourriez demander à quelqu’un de “commencer en silence, d’augmenter lentement le volume jusqu’au maximum, le maintenir un moment, puis revenir rapidement au silence”. Sonic Pi vous permet de programmer ceci avec les enveloppes.

Juste pour se remémorer, une amplitude de 0 est le silence et une amplitude de 1 est le volume normal.

Maintenant, regardons chaque partie de l’enveloppe tour à tour.

## Durée d’extinction (Release)

La seul partie de l’enveloppe qui est utilisée par défaut est la durée d’extinction. C’est la durée qu’il faut pour que le son du synthé se termine. Tous les synthés ont une durée de “release” de 1, ce qui signifie qu’ils ont une durée d’un temps musical (qui par défaut est 1 seconde) avant extinction :

    play 70

Cette note va être audible pendant 1 seconde. Vous pouvez chronométrer :-) C’est la version abrégée de la version longue plus explicite :

    play 70, release: 1

Observez comme cela sonne exactement pareil (le son dure pendant une seconde). Néanmoins, c’est désormais très simple de changer la durée en modifiant la valeur de l’option `release:` :

    play 60, release: 2

Nous pouvons faire jouer un synthé pendant une très courte durée en utilisant une durée de “release” très petite :

    play 60, release: 0.2

La durée d’extinction du son est appelée “phase d’extinction” et est par défaut une transition linéaire (c’est-à-dire une ligne droite). Le schéma suivant illustre cette transition :

La ligne verticale tout à gauche du schéma montre que le son démarre de l’amplitude 0, mais monte jusqu’à l’amplitude totale immédiatement (c’est la phase d’attaque que nous couvrirons ensuite). Une fois à l’amplitude totale, il redescend en ligne droite jusqu’à zéro en prenant le temps spécifié par `release:`. Des durées de “release” plus longues produisent des fondus à la fermeture de synthé plus longs.

Vous pouvez ainsi changer la durée de vos sons en changeant la durée d’extinction. Jouez un moment en ajoutant des durées de “release” à votre musique.

## Phase d’attaque

Par défaut, la phase d’attaque est fixée à 0 pour tous les synthés, ce qui signifie qu’ils évoluent de l’amplitude 0 à l’amplitude 1 immédiatement. Cela donne initialement au synthé un son percussif. Toutefois, vous pouvez souhaiter une montée progressive de votre son. Ceci peut être obtenu avec l’option `attack:`. Essayez des montées progressives de quelques sons :

    play 60, attack: 2
    sleep 3
    play 65, attack: 0.5

Vous pouvez utiliser des options multiples en même temps. Par exemple, pour une attaque courte et une extinction lente, essayez :

    play 60, attack: 0.7, release: 4

Cette attaque courte et cette extinction lente sont illustrées dans le schéma suivant :

Bien entendu, vous pouvez inverser les choses. Essayez une attaque longue et une extinction rapide :

    play 60, attack: 4, release: 0.7

Finalement, vous pouvez aussi avoir à la fois une attaque et une extinction rapides pour des sons plus courts.

    play 60, attack: 0.5, release: 0.5

## Durée de soutien (“Sustain”)

En plus de spécifier des durées d’attaque et d’extinction, vous pouvez aussi spécifier une durée de soutien. C’est la durée pendant laquelle le son est maintenu à l’amplitude maximale entre les phases d’attaque et d’extinction.

    play 60, attack: 0.3, sustain: 1, release: 1

La durée de soutien est utile pour des sons importants auxquels vous voulez donner une présence permanente dans le mixage avant d’entrer dans une phase optionnelle d’extinction. Bien entendu, c’est entièrement valide de fixer à la fois les options d’attaque et d’extinction à 0 et d’utiliser seulement le soutien pour n’avoir absolument pas de montée et d’extinction progressives. Cependant, faites attention, une durée d’extinction de 0 peut produire des clics dans l’écoute et c’est souvent mieux d’utiliser une très petite valeur comme 0.2.

## Phase de déclin (“Decay”)

Finalement, pour les cas où vous aurez besoin d’un niveau de contrôle supplémentaire, vous pourrez aussi spécifier une durée de déclin. C’est la phase de l’enveloppe qui s’intercale entre les phases d’attaque et de soutien et qui spécifie la durée pendant laquelle l’amplitude va descendre du niveau `attack_level:` jusqu’au niveau `decay_level:` (qui si on ne le définit pas explicitement sera égal au `sustain_level:`). Par défaut, l’option `decay:` est à 0 et à la fois les niveaux “attack” et “sustain” sont à 1. Ainsi vous aurez besoin de les spécifier en plus de la durée de déclin pour obtenir un effet :

    play 60, attack: 0.1, attack_level: 1, decay: 0.2, sustain_level: 0.4, sustain: 1, release: 0.5

## Niveau de chute

Une dernière astuce est que même si l’option `decay_level:` a par défaut la même valeur que `sustain_level:`, on peut leur donner explicitement des valeurs différentes pour un contrôle complet de l’enveloppe. Cela nous permet de créer des enveloppes comme ceci :

    play 60, attack: 0.1, attack_level: 1, decay: 0.2, decay_level: 0.3, sustain: 1, sustain_level: 0.4, release: 0.5

Il est aussi possible de choisir un `decay_level:` plus haut que le `sustain_level:` :

    play 60, attack: 0.1, attack_level: 0.1, decay: 0.2, decay_level: 1, sustain: 0.5, sustain_level: 0.8, release: 1.5

## Enveloppes ADSR

Ainsi pour résumer, les enveloppes de Sonic Pi ont les phases suivantes :

1. attack - durée de passage de l’amplitude 0 jusqu’au niveau `attack_level`,
2. decay - durée pour passer l’amplitude du niveau `attack_level` jusqu’au niveau `decay_level` ,
3. sustain - durée pour faire passer l’amplitude du niveau `decay_level` au niveau `sustain_level`,
4. release - durée pour passer l’amplitude du niveau `sustain_level` au niveau 0

Il est important de noter que la durée d’un son est la somme des durées de chacune de ces phases. Ainsi le son suivant aura une durée de 0.5 + 1 + 2 + 0.5 = 4 temps musicaux :

    play 60, attack: 0.5, attack_level: 1, decay: 1, sustain_level: 0.4, sustain: 2, release: 0.5

Maintenant, allez et jouez un moment en ajoutant des enveloppes à vos sons.

# 3 - Échantillons (“Samples”)

Un autre grand moyen de développer votre musique est d’utiliser des sons pré-enregistrés. Dans la grande tradition hip-hop, on appelle ces sons pré-enregistrés samples. Aussi, si vous prenez un micro à l’extérieur, et allez enregistrer le son de la pluie frappant une toile, vous avez tout simplement créé un “sample”.

Sonic Pi vous offre des tas de choses amusantes à faire avec les “samples”. Non seulement il est livré avec 130 échantillons du domaine public, prêts pour faire un boeuf, mais il vous permet de jouer et de manipuler les vôtres propres. Allons voir…

# 3.1 - Lecture des échantillons

Jouer des beeps est seulement un début. Une chose qui est très plaisante est de déclencher des échantillons pré-enregistrés. Essayez-le :

    sample :ambi_lunar_land

Sonic Pi inclut beaucoup d’échantillons à jouer. Vous pouvez les utiliser juste comme vous utilisez la commande `play`. Pour jouer des échantillons et des notes multiples, écrivez-les simplement les uns après les autres :

    play 36
    play 48
    sample :ambi_lunar_land
    sample :ambi_drone

Si vous voulez les espacer dans le temps, utilisez la commande `sleep` :

    sample :ambi_lunar_land
    sleep 1
    play 48
    sleep 0.5
    play 36
    sample :ambi_drone
    sleep 1
    play 36

Notez que Sonic Pi n’attend pas la fin d’un son pour démarrer le suivant. La commande `sleep` décrit uniquement la séparation du déclenchement des sons. Ceci vous permet de superposer les sons en couches en créant d’intéressants effets de chevauchement. Plus tard dans ce tutoriel, nous jetterons un œil sur le contrôle de la durée de ces sons avec des enveloppes.

## Découverte des échantillons

Il y a deux manière de découvrir l’étendue des échantillons fournis par Sonic Pi. En premier lieu, on peut utiliser le système d’aide. Cliquez sur “Échantillons” dans le menu horizontal du bas, choisissez votre catégorie et vous verrez une liste des sons disponibles.

Alternativement, vous pouvez utiliser le système d’auto-complétion. Tapez simplement le début d’un groupe d’échantillons comme : `sample :ambi_` et vous verrez apparaître une liste de noms d’échantillons qui vous permettra d’en sélectionner un. Essayez les préfixes de catégorie suivants :

- `:ambi_`
- `:bass_`
- `:elec_`
- `:perc_`
- `:guit_`
- `:drum_`
- `:misc_`
- `:bd_`

Maintenant commencez à introduire des échantillons dans vos compositions !

# 3.2 - Paramètres des échantillons : Amp et Pan

Comme nous l’avons vu avec les synthés, nous pouvons aisément contrôler nos sons avec des paramètres. Les “Samples” supportent exactement le même mécanisme de paramètrage. Revisitons nos amis `amp:` et `pan:`.

## Amplitude des échantillons

Vous pouvez changer l’amplitude des échantillons avec exactement la même approche que vous avez utilisée pour les synthés :

    sample :ambi_lunar_land, amp: 0.5

## Balance des échantillons

Nous pouvons aussi utiliser le paramètre `pan:` avec les échantillons. Par exemple, voici comment nous jouerions le break amen au début vers la gauche, puis à mi-parcours, vers la droite :

    sample :loop_amen, pan: -1
    sleep 0.877
    sample :loop_amen, pan: 1

Notez que 0.877 est la moitié de la durée en secondes de l’échantillon `:loop_amen`.

Finalement, notez que si vous fixez des valeurs par défaut avec `use_synth_defaults` (que nous détaillerons plus tard), elles seront ignorées par `sample`.

# 3.3 - Étirement des échantillons

Maintenant que nous pouvons jouer une variété de synthés et d’échantillons pour créer une musique, il est temps d’apprendre comment modifier à la fois les synthés et les échantillons pour faire de la musique encore plus originale et intéressante. En premier, explorons la faculté d’étirer et de compresser les échantillons.

## Représentation des échantillons

Les échantillons (“samples”) sont des sons pré-enregistrés stockés à l’aide de nombres qui représentent comment se déplace la membrane du haut-parleur pour reproduire le son. La membrane du haut-parleur peut avancer et reculer, et ainsi les nombres ont juste besoin de représenter la distance d’avancée ou de recul que la membrane doit avoir pour chaque moment dans le temps. Pour être capable de reproduire fidèlement un son enregistré, un échantillon a typiquement besoin de stocker des milliers de nombres par seconde ! Sonic Pi prend cette liste de nombres et en alimente à la bonne vitesse l’ordinateur pour faire avancer et reculer comme il le faut la membrane de son haut-parleur pour reproduire le son. Cependant, c’est aussi amusant de changer la vitesse à laquelle est alimenté le haut-parleur pour changer le son.

## Changement de vitesse (“Rate”)

Jouons avec un des sons d’ambiance : `:ambi_choir`. Pour le jouer avec la vitesse par défaut, vous pouvez passer une option `rate:` au `sample` :

    sample :ambi_choir, rate: 1

Ceci le joue à la vitesse normale (1), aussi rien de spécial pour l’instant. Cependant, vous êtes libre de changer ce nombre pour une autre valeur. Essayons `0.5` :

    sample :ambi_choir, rate: 0.5

Wow ! Que se passe-t-il ici ? Eh bien, deux choses. Premièrement, l’échantillon est joué pendant 2 fois plus de temps, deuxièmement le son est à une octave en-dessous. Explorons ces choses un peu plus en détails.

## Étirons

Un échantillon qui est amusant à étirer ou à compresser est le break Amen. A vitesse normale, on pourrait imaginer de l’insérer dans une piste de drum ‘n’ bass :

    sample :loop_amen

Toutefois en modifiant la vitesse on peut changer de genre. Essayez de réduire de moitié la vitesse pour un hip-hop old school :

    sample :loop_amen, rate: 0.5

Si nous l’accélérons, nous entrons dans le territoire de la jungle :

    sample :loop_amen, rate: 1.5

Maintenant pour notre astuce finale - voyons ce qui se passe lorsque nous utilisons un “rate” négatif :

    sample :loop_amen, rate: -1

Ouhaou ! Il le joue à l’envers ! Maintenant, essayez de jouer avec des tas d’échantillons différents avec des vitesses différentes. Essayez des vitesses très rapides et des vitesses vraiment lentes. Voyez quels sons intéressants vous pouvez produire.

## Une simple explication de la vitesse d’échantillon (“sample rate”)

Un moyen imagé d’assimiler les échantillons est de penser aux ressorts. La vitesse de lecture est comme l’étirement et la compression du ressort. Si vous jouez l’échantillon à la vitesse 2, vous compressez le ressort à la moitié de sa longueur normale. Ainsi l’échantillon met la moitié du temps à être joué puisqu’il est plus court. Si vous jouez l’échantillon à la moitié de la vitesse, vous étirez le ressort au double de sa longueur. Ainsi l’échantillon met deux fois plus de temps à être joué puisqu’il est plus long. Plus vous compressez (vitesse plus élevée), plus il devient court, plus vous étirez (vitesse plus lente), plus il devient long.

Compresser un ressort augmente sa densité (le nombre de spires par cm) : ceci est similaire à l’échantillon sonnant plus aigu. Étirer le ressort diminue sa densité, c’est similaire à un son plus grave.

## Les maths derrière la vitesse d’échantillon

(Cette section est fournie pour ceux que les détails intéressent. Soyez libre de la sauter…)

Comme nous l’avons vu ci-dessus, un échantillon est représenté par une longue liste de nombres qui représentent la position où devrait être la membrane du haut-parleur dans le temps. Nous pouvons prendre cette liste de nombres et l’utiliser pour tracer un graphique qui ressemblerait à ceci :

Vous avez peut-être déjà vu des images comme cela. C’est appelé la forme d’onde d’un échantillon. C’est juste un graphique de nombres. Typiquement, une forme d’onde comme cela aura 44100 points de données par seconde (en application du théorème d’échantillonnage de Nyquist-Shannon). Ainsi, si l’échantillon dure 2 secondes, la forme d’onde sera représentée par 88200 nombres qui alimenteront le haut-parleur à la vitesse de 44100 points par seconde. Bien sûr, nous pouvons l’alimenter à une vitesse double qui serait de 88200 points par seconde. Ceci prendrait ainsi une seconde seulement à être joué. Nous pourrions aussi le jouer à la moitié de la vitesse qui serait donc de 22050 points par seconde, en prenant 4 secondes pour être joué.

La durée d’un échantillon est affectée par la vitesse de jeu :

- Doubler la vitesse de jeu diminue de moitié la durée du jeu,
- Diminuer de moitié la vitesse de jeu double la durée de jeu,
- Utiliser une vitesse de jeu d’un quart quadruple la durée du jeu,
- Utiliser une vitesse de jeu de 1/10 fait durer le jeu 10 fois plus longtemps.

On peut représenter ceci avec la formule :

    nouvelle_durée = (1 / rate) * durée_normale

Changer la vitesse de jeu affecte aussi la hauteur du son. La fréquence ou le ton d’une forme d’onde est déterminé par la vitesse à laquelle elle monte et descend. Notre cerveau curieusement change le mouvement rapide de la membrane du haut-parleur en notes hautes et le mouvement lent en notes basses. C’est pourquoi vous pouvez quelquefois voir un gros haut-parleur de basse bouger en émettant une super basse - il va et vient beaucoup moins vite qu’un haut-parleur produisant des notes plus aiguës.

Si vous prenez une forme d’onde et que vous la compressez, elle va monter et descendre plus de fois par seconde. Ceci va faire un son plus aigu. On en déduit que doubler le montant des mouvements de montée et descente (oscillations) double la fréquence. Ainsi, jouer votre échantillon à double vitesse double la fréquence que vous entendez. De même, diminuer de moitié la vitesse va diminuer de moitié la fréquence. D’autres vitesses affecteront la fréquence dans le même sens.

# 3.4 - Échantillons enveloppés

Il est aussi possible de modifier la durée et l’amplitude d’un échantillon en utilisant une enveloppe ADSR. Toutefois, ceci fonctionne d’une manière légèrement différente de l’enveloppe ADSR applicable aux synthés. Les enveloppes d’échantillon permettent uniquement de réduire l’amplitude et la durée de l’échantillon - et jamais de les augmenter. Le jeu de l’échantillon s’arrêtera soit quand l’échantillon arrivera à sa fin, soit quand la fin l’enveloppe sera atteinte. Donc si vous utilisez une phase de `release:` très longue, cela n’allongera pas la durée de l’échantillon.

## Des enveloppes pour Amen

Retournons à notre fidèle ami le break Amen :

    sample :loop_amen

Sans options, nous entendons la totalité de l’échantillon à son amplitude totale. Si nous voulons une attaque progressive sur une seconde, nous pouvons utiliser le paramètre `attack:` :

    sample :loop_amen, attack: 1

Pour une attaque plus courte, choisissez une valeur `attack:` plus petite :

    sample :loop_amen, attack: 0.3

## Soutien automatique (“Auto Sustain”)

Le comportement de l’enveloppe ADSR diffère de l’enveloppe standard des synthés pour la valeur de sustain. Dans l’enveloppe standard des synthés, la valeur par défaut du soutien est 0 à moins que vous ne la fixiez manuellement. Avec les échantillons, la valeur par défaut du soutien est une valeur auto-magique - le temps qu’il reste pour finir l’échantillon. C’est pour cela que nous entendons l’échantillon en entier quand une valeur n’est pas spécifiée. Si les valeurs de l’attaque, du déclin, du soutien et de l’extinction étaient toutes à 0, nous n’entendrions pas le moindre gazouillis. Donc, de la longueur de l’échantillon, Sonic Pi déduit les éventuelles durées d’attaque, de déclin et d’extinction et utilise le résultat pour votre durée de soutien. Si la somme des durées d’attaque, de déclin et d’extinction est supérieure à la durée de l’échantillon, le soutien est simplement fixé à 0.

## Extinctions progressives

Pour explorer ceci, regardons notre Amen de manière plus détaillée. Si nous demandons à Sonic Pi quelle est la longueur de l’échantillon :

    print sample_duration :loop_amen

Il affichera `1.753310657596372`, ce qui est la longueur de l’échantillon en secondes. Arrondissons-le ici à `1.75` par commodité. Maintenant si nous fixons l’extinction à `0.75`, quelque chose de surprenant va se passer :

    sample :loop_amen, release: 0.75

La première seconde de l’échantillon va être jouée à l’amplitude totale avant de s’estomper progressivement sur une durée de 0.75 secondes. C’est l’auto-soutien en action. Par défaut, la phase d’extinction fonctionne de manière à s’achever à la fin de l’échantillon. Si notre échantillon avait 10.75 secondes de longueur, il serait joué 10 secondes à l’amplitude totale avant de s’estomper progressivement pendant 0.75 secondes.

Rappelez-vous : par défaut, la phase `release:` amène à l’extinction complète à la fin de l’échantillon.

## Attaque et extinction progressives

On peut utiliser à la fois les paramètres `attack:` et `release:` ensemble grâce au comportement du soutien automatique pour des attaques et des extinctions progressives :

    sample :loop_amen, attack: 0.75, release: 0.75

Comme la durée totale de l’échantillon est de 1.75 s et que la somme des phases d’attaque et d’extinction fait 1.5 s, le soutien est automatiquement ajusté à 0.25 s. Ceci nous permet de programmer facilement une attaque et une extinction progressives de l’échantillon.

## Soutien explicite

Nous pouvons facilement revenir au comportement normal de l’enveloppe ADSR des synthés en fixant manuellement `sustain:` à une valeur comme 0 :

    sample :loop_amen, sustain: 0, release: 0.75

Maintenant, notre échantillon n’est joué que pendant 0.75 s au total. Avec les valeurs 0 par défaut pour `attack:` et `decay:` , l’échantillon monte directement à l’amplitude totale, se maintient là pendant 0 s et redescend progressivement à l’amplitude 0 pendant la phase d’extinction : 0.75 s.

## Cymbales percussives

Nous pouvons utiliser ce comportement pour obtenir de bons effets en transformant un échantillon qui sonne longtemps en versions plus percussives. Intéressons-nous à l’échantillon `:drum_cymbal_open` :

    sample :drum_cymbal_open

Vous pouvez entendre la cymbale sonnant pendant une certaine durée. Toutefois, nous pouvons utiliser notre enveloppe pour la rendre plus percussive :

    sample :drum_cymbal_open, attack: 0.01, sustain: 0, release: 0.1

Vous pouvez émuler la frappe de la cymbale suivie d’un étouffement en augmentant la phase de soutien :

    sample :drum_cymbal_open, attack: 0.01, sustain: 0.3, release: 0.1

Maintenant allez et prenez plaisir à mettre des enveloppes sur vos échantillons. Essayez aussi de changer la vitesse pour des résultats vraiment intéressants.

# 3.5 - Échantillons partiels

Cette section va conclure notre exploration du lecteur d’échantillons de Sonic Pi. Faisons un rapide résumé. Jusqu’à maintenant nous avons vu comment lire des échantillons :

    sample :loop_amen

Nous avons ensuite vu comment changer la vitesse de lecture des échantillons en les jouant par exemple deux fois moins vite :

    sample :loop_amen, rate: 0.5

Ensuite, nous avons vu comment nous pouvions obtenir une attaque progressive (faisons-le à vitesse moitié) :

    sample :loop_amen, rate: 0.5, attack: 1

Nous avons aussi vu comment nous pouvions utiliser le début d’un échantillon en percussion en donnant à `sustain:` une valeur explicite et en assignant des valeurs faibles à la fois à `attack:` et à `release:` :

    sample :loop_amen, rate: 2, attack: 0.01, sustain: 0, release: 0.35

Toutefois ne serait-il pas sympathique de ne pas avoir à toujours démarrer au début de l’échantillon ? Ne serait-ce pas également sympathique de ne pas avoir à finir toujours à la fin de l’échantillon ?

## Choix d’un point de départ

Il est possible de choisir un point arbitraire de départ dans l’échantillon au moyen d’une valeur comprise entre 0 et 1 où 0 est le début de l’échantillon, 1 est la fin et 0.5 le milieu. Essayons de jouer seulement la dernière moitié du break “Amen” :

    sample :loop_amen, start: 0.5

Ou pour le dernier quart de l’échantillon :

    sample :loop_amen, start: 0.75

## Choix d’un point de terminaison

De manière similaire, il est possible de choisir un point de terminaison arbitraire au moyen d’une valeur comprise entre 0 et 1. Terminons le break “Amen” à la moitié de son parcours :

    sample :loop_amen, finish: 0.5

## Spécification du départ et de la terminaison

Bien sûr, nous pouvons combiner ces deux paramètres pour jouer des segments arbitraires du fichier audio. Comment jouer uniquement une petite section au milieu :

    sample :loop_amen, start: 0.4, finish: 0.6

Que se passe-t-il si nous choisissons une position de départ postérieure au point de terminaison ?

    sample :loop_amen, start: 0.6, finish: 0.4

Cool ! Ça joue à l’envers !

## Combinaison avec la vitesse

Nous pouvons combiner cette nouvelle possibilité de jouer des segments arbitraires avec notre ami `rate:`. Par exemple, nous pouvons jouer une très petite section du break “Amen” très lentement :

    sample :loop_amen, start: 0.5, finish: 0.7, rate: 0.2

## Combinaison avec les enveloppes

Finalement, nous pouvons combiner tout ceci avec nos enveloppes ADSR pour produire des résultats intéressants :

    sample :loop_amen, start: 0.5, finish: 0.8, rate: -0.2, attack: 0.3, release: 1

Maintenant allez et jouez un moment en triturant les échantillons avec ces choses amusantes…

# 3.6 - Échantillons externes

Bien que les échantillons fournis en interne puissent vous motiver et vous faire démarrer rapidement, vous pourriez souhaiter d’expérimenter d’autres sons pré-enregistrés dans votre musique. Sonic Pi supporte complètement cela. En premier lieu toutefois ayons une rapide discussion sur la portabilité de votre œuvre.

## Portabilité

Quand vous composez votre morceau uniquement avec des synthés et des échantillons internes, le code est tout ce dont vous avez besoin pour reproduire fidèlement votre musique. Pensez à cela un instant – c’est génial ! Un simple morceau de texte que vous pouvez envoyer par courriel ou coller dans un Gist représente tout ce dont vous avez besoin pour reproduire vos sons. Cela le rend vraiment facile à partager avec vos amis puisqu’ils ont juste besoin de se procurer le code.

Toutefois, si vous commencez à utiliser vos propres échantillons pré-enregistrés, vous perdez cette portabilité. C’est parce que pour reproduire votre musique les autres ont besoin non seulement de votre code, mais aussi de vos échantillons. Ceci limite la capacité pour les autres de manipuler, triturer et expérimenter avec votre oeuvre. Bien entendu, ceci ne doit pas vous empêcher d’utiliser vos propres échantillons, c’est juste quelque chose à prendre en compte.

## Échantillons locaux

Alors comment faire pour jouer n’importe quel fichier WAV, AIFF, OGG, OGA, FLAC ou MP3 sur votre ordinateur ? Tout ce dont vous avez besoin est de renseigner le chemin de ce fichier à `sample` :

    # Raspberry Pi, Mac, Linux
    sample "/Users/sam/Desktop/my-sound.wav"
    # Windows
    sample "C:/Users/sam/Desktop/my-sound.wav"

Sonic Pi chargera automatiquement et jouera votre échantillon. Vous pouvez aussi passer tous les paramètres que vous avez l’habitude de passer à `sample` :

    # Raspberry Pi, Mac, Linux
    sample "/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3
    # Windows
    sample "C:/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3

# 3.7 - Paquets de samples

Note : cette section du tutoriel couvre le sujet avancé de travailler avec des grands dossiers de vos propres samples. Ce sera le cas si vous avez téléchargé ou acheté vos propre paquets de samples et souhaitez les utiliser dans Sonic Pi.

N’hésitez pas à sauter cette section si vous vous contentez des samples fournis dans Sonic Pi.

Quand on travaille avec de grands dossiers de samples externes il peut être ennuyeux de taper le chemin entier chaque fois qu’on veut déclencher un sample particulier.

Par exemple, imaginons que vous avez le dossier suivant sur votre machine :

    /path/to/my/samples/

Quand on regarde dans ce dossier on voit les samples suivants :

- `100_A#_melody1.wav`
- `100_A#_melody2.wav`
- `100_A#_melody3.wav`
- `120_A#_melody4.wav`
- `120_Bb_guit1.wav`
- `120_Bb_piano1.wav`

Typiquement pour jouer le sample de piano on peut utiliser le chemin complet :

    sample "/path/to/my/samples/120_Bb_piano1.wav"

Si on veut jouer le sample de guitare on peut aussi utiliser son chemin complet :

    sample "/path/to/my/samples/120_Bb_guit.wav"

Cependant ces deux appels de `sample` nous forcent à connaître le nom de chacun des samples de notre dossier. Et si on voulait juste écouter chaque sample à son tour rapidement ?

## Indexer les paquets de samples

Si on veut jouer le premier sample d’un dossier on peut juste passer le nom du dossier à `sample` et l’index `0` comme suit :

    sample "/path/to/my/samples/", 0

On peut même construire un raccourci vers notre chemin de dossier en utilisant une variable :

    samps = "/path/to/my/samples/"
    sample samps, 0

Maintenant, si on veut jouer le deuxième sample de notre dossier, on peut juste incrémenter notre index :

    samps = "/path/to/my/samples/"
    sample samps, 1

Remarquez qu’on n’a plus besoin de connaître le nom des samples du dossier : on doit juste connaître le dossier lui-même (ou avoir un raccourci vers lui). Si on demande un index qui est plus grand que le nombre de samples, il va juste boucler comme pour les anneaux. Ainsi, quel que soit le nombre qu’on utilise on a la garantie de récupérer un des samples de ce dossier.

## Filtrer des paquets de samples

D’habitude indexer suffit, mais parfois on a besoin de plus de puissance pour trier et organiser nos échantillons. Heureusement de nombreux paquets d’échantillons ajoutent des informations utiles dans les noms de fichiers. Jetons un autre œil aux noms de fichier des échantillons de notre dossier :

- `100_A#_melody1.wav`
- `100_A#_melody2.wav`
- `100_A#_melody3.wav`
- `120_A#_melody4.wav`
- `120_Bb_guit1.wav`
- `120_Bb_piano1.wav`

Remarquez que dans ces noms de fichier nous avons pas mal d’informations. On a le BPM du sample (nombre de battements par minute) au début. Donc le sample de piano est à 120 BPM et nos trois premières mélodies sont à 100 BPM. Nos noms de samples contiennent aussi la clef. Donc le sample de guitare est en Bb (Si bémol) et les mélodies sont en A# (La dièse). Cette information est très utile pour mélanger ces samples avec le reste de notre code. Par exemple, on sait qu’on ne peut jouer le sample de piano que dans du code qui est à 120 BPM et dans la clef de Bb.

Il se trouve qu’on peut utiliser cette convention de nommage particulière de nos ensembles de samples dans le code pour nous aider à ne garder que ceux qu’on veut. Par exemple, si nous travaillons à 120 BPM, on peut ne garder que les samples qui contiennent la chaîne `"120"` avec le code suivant :

    samps = "/path/to/my/samples/"
    sample samps, "120"

Cela jouera le premier sample qui correspond. Si on veut le deuxième, il suffit d’utiliser l’index :

    samps = "/path/to/my/samples/"
    sample samps, "120", 1

On peut même utiliser de multiples filtres en même temps. Par exemple, si on veut un sample dont le nom de fichier contient à la fois les sous-chaînes “120” et “A#”, on peut le trouver facilement avec le code suivant :

    samps = "/path/to/my/samples/"
    sample samps, "120", "A#"

Enfin, on a toujours la possibilité d’ajouter nos options habituelles lors de l’appel à `sample` :

    samps = "/path/to/my/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2

## Sources

Le système de pré-argument de filtre de samples comprend deux types d’information : les sources et les filtres. Les sources sont des informations utilisées pour créer la liste des candidats potentiels. Une source peut prendre deux formes :

1. “/path/to/samples” : une chaîne représentant un chemin valide vers un dossier
2. “/path/to/samples/foo.wav” : une chaîne représentant un chemin valide vers un fichier sample

La fonction `sample` va d’abord rassembler toutes les sources et les utiliser pour créer une grande liste de candidats. Cette liste est construite en ajoutant d’abord tous les chemins valides puis en ajoutant tous les fichiers valides `.flac`, `.aif`, `.aiff`, `.wav`, `.wave`, et `.mp3` contenus dans les dossiers.

Par exemple, regardez le code suivant :

    samps = "/path/to/my/samples/"
    samps2 = "/path/to/my/samples2/"
    path = "/path/to/my/samples3/foo.wav"
    sample samps, samps2, path, 0

Ici nous combinons les contenus des samples de deux dossiers en y ajoutant un sample en particulier. Si `"/path/to/my/samples/"` contient trois samples et `"/path/to/my/samples2/"` en contient douze, on aurait seize samples potentiels à indexer et filtrer (3 + 12 + 1).

Par défaut, seuls les fichiers de samples d’un dossier sont rassemblés dans la liste de candidats. Parfois vous pourriez avoir un certain nombre de dossiers imbriqués dans lesquels vous aimeriez chercher et filtrer. Vous pouvez faire une recherche récursive dans tous les samples de tous les sous-dossiers d’un dossier en particulier en ajoutant `**` à la fin du chemin :

    samps = "/path/to/nested/samples/**"
    sample samps, 0

Attention parce que chercher dans un très grand ensemble de dossiers peut prendre beaucoup de temps. Cela dit, le contenu des dossiers sources est mis en cache, donc le retard n’arrivera que la première fois.

Enfin, notez que les sources doivent être en premier. Si aucune source n’est donnée, alors l’ensemble de samples fourni par défaut sera pris comme liste des candidats.

## Filtres

Une fois qu’on a une liste de candidats on peut utiliser les types de filtres suivants pour réduire la sélection :

- `"foo"` : les chaînes vont filtrer sur les occurrences de sous-chaîne dans le nom du fichier (moins le chemin du dossier et l’extension).
- `/fo[oO]/` : les expressions régulières filtrent sur des motifs du nom du fichier (moins le chemin du dossier et l’extension).
- `:foo` : les mots-clefs filtrent les candidats si le mot-clef correspond exactement au nom du fichier (moins le chemin du dossier et l’extension).
- `lambda{|a| ... }` : les procédures avec un argument seront traitées comme un filtre de candidat ou une fonction génératrice. On lui passera la liste des candidats actuels et elle doit retourner une nouvelle liste de candidats (une liste de chemins valides vers des fichiers de samples).
- `1` : Les nombres sélectionnent le candidat avec cet index (en bouclant comme un anneau si nécessaire).

Par exemple on peut filtrer tous les samples d’un dossier qui contiennent la chaîne `"foo"` et jouer le premier sample correspondant deux fois moins vite :

    sample "/path/to/samples", "foo", rate: 0.5

Regardez l’aide pour `sample`, elle contient plusieurs exemples détaillés d’utilisation. Notez que l’ordre des filtres est respecté.

## Composites

Enfin vous pouvez utiliser des listes partout où on peut placer une source ou un filtre. La liste sera automatiquement aplatie et son contenu sera traité comme des sources et filtres. Ainsi les appels suivants à `sample` sont sémantiquement équivalents :

    sample "/path/to/dir", "100", "C#"
    sample ["/path/to/dir", "100", "C#"]
    sample "/path/to/dir", ["100", "C#"]
    sample ["/path/to/dir", ["100", ["C#"]]]

## Résumé

C’était une section avancée pour les gens qui ont besoin de vraie puissance pour manipuler et utiliser des paquets de samples. Si la plupart de cette section n’avait pas trop de sens pour vous, ne vous inquiétez pas. Vous n’avez probablement pas encore besoin de cette fonctionnalité. Mais vous vous rendrez compte quand vous en aurez besoin et vous pourrez revenir et relire ceci quand vous commencerez à travailler avec de grands dossiers de samples.

# 4 - Aléatoire

Un grand moyen d’ajouter de l’intérêt à votre musique est d’utiliser des nombres aléatoires (“random”). Sonic Pi a des fonctions remarquables pour ajouter de l’aléatoire à votre musique, mais avant de commencer, nous devons apprendre une vérité choquante : dans Sonic Pi l’aléatoire n’est pas vraiment aléatoire. Qu’est-ce que cela signifie ? Eh bien, voyons-le.

## Répétabilité

Une fonction vraiment utile est `rrand` qui vous donnera une valeur aléatoire comprise entre deux nombres : un min et un max. (`rrand` est l’abréviation de “ranged random”). Essayons de jouer une note aléatoire :

    play rrand(50, 95)

Oh, une note aléatoire a été jouée. La note `83.7527` a été jouée. Une note aléatoire sympathique entre 50 et 95. Wow , attendez, est-ce que je viens juste de prédire exactement la note que vous avez obtenue ? Quelque chose de louche se passe ici. Essayez d’exécuter le code une nouvelle fois. Comment ? `83.7527` a encore été choisie ? Ce ne peut être aléatoire !

La réponse est que ce n’est pas vraiment aléatoire, c’est pseudo-aléatoire. Sonic Pi vous donne une suite d’un semblant de nombres aléatoires de manière reproductible. C’est très utile pour s’assurer que la musique que vous avez créée sur votre machine sonnera de façon identique sur n’importe quelle autre machine - même si vous utilisez de l’aléatoire dans votre composition.

Bien sûr, dans un morceau de musique donné, si `83.7527` était choisi ‘aléatoirement’ à chaque fois, ce ne serait pas très intéressant. Ce n’est cependant pas le cas. Essayez ce qui suit :

    loop do
      play rrand(50, 95)
      sleep 0.5
    end

Oui ! Ca sonne enfin aléatoire. A l’intérieur d’un run donné, des appels successifs à des fonction aléatoires retournent des valeurs aléatoires. Cependant, une nouvelle exécution produira exactement la même séquence de valeurs aléatoires et sonnera exactement pareil. C’est comme si tout le code de Sonic Pi revenait en arrière exactement au même point de départ chaque fois que le bouton “Run” était pressé. C’est le “Un jour sans fin” de la synthèse musicale !

## Cloches hantées

Une agréable illustration de l’aléatoire en action est l’exemple des cloches hantées qui fait boucler l’échantillon `:perc_bell` avec une vitesse et un temps de repos aléatoires entre les sons de cloche :

    loop do
      sample :perc_bell, rate: (rrand 0.125, 1.5)
      sleep rrand(0.2, 2)
    end

## Limite (“cutoff”) aléatoire

Un autre exemple sympathique d’aléatoire est de modifier la limite d’un son de synthé aléatoirement. Un synthé super pour essayer cela est l’émulateur du `:tb303` :

    use_synth :tb303
    loop do
      play 50, release: 0.1, cutoff: rrand(60, 120)
      sleep 0.125
    end

## Tête de série aléatoire

Alors que faire si vous n’aimez pas cette particulière séquence de nombres aléatoires que fournit Sonic Pi ? Eh bien, c’est tout à fait possible de choisir un autre point de départ via `use_random_seed`. La tête de série par défaut est 0, aussi choisissez une autre tête de série pour une expérience aléatoire différente !

Envisagez ce qui suit :

    5.times do
      play rrand(50, 100)
      sleep 0.5
    end

Chaque fois que vous exécuterez ce code, vous entendrez la même séquence de 5 notes. Pour obtenir une séquence différente, changez simplement la tête de série :

    use_random_seed 40
    5.times do
      play rrand(50, 100)
      sleep 0.5
    end

Ceci va produire une séquence différente de 5 notes. En changeant le tête de série et en écoutant les résultats, vous pouvez trouver quelque chose que vous aimez - et quand vous le partagerez avec d’autres, ils entendront exactement ce que vous avez aussi entendu.

Jetons un œil sur d’autres fonctions aléatoires utiles.

## Choix (“choose”)

Une chose très commune est de choisir un item aléatoirement dans une liste d’items connus. Par exemple, je peux vouloir jouer une note parmi les suivantes : 60, 65 ou 72. Je peux y arriver avec `choose` qui me choisit un item dans une liste. En premier, je dois mettre mes nombres dans une liste, ce qui est réalisé en les encadrant entre crochets et en les séparant avec des virgules : `[60, 65, 72]`. Ensuite, j’ai juste besoin de leur passer `choose` :

    choose([60, 65, 72])

Écoutons comment cela sonne :

    loop do
      play choose([60, 65, 72])
      sleep 1
    end

## rrand

Nous avons déjà vu `rrand`, mais examinons-le encore. Il retourne un nombre aléatoire entre deux valeurs exclues. Cela signifie qu’il ne retournera jamais soit la borne basse, soit la borne haute - toujours quelque chose entre les deux. Le nombre sera toujours un nombre flottant - ce qui signifie que ce n’est pas un nombre entier, mais une fraction de nombre. Exemple de flottants retournés par `rrand(20, 110)` :

- 87.5054931640625
- 86.05255126953125
- 61.77825927734375

## rrand_i

Occasionnellement, vous désirez un nombre entier aléatoire, pas un flottant. C’est là que `rrand_i` arrive à la rescousse. Il fonctionne de façon similaire à `rrand` sauf qu’il peut retourner potentiellement les valeurs minimales et maximales comme valeurs aléatoires (ce qui signifie que c’est inclusif plutôt qu’exclusif des bornes). Exemple de nombres retournés par `rrand_i(20, 110)` :

- 88
- 86
- 62

## rand

Cette fonction va retourner un flottant aléatoire entre 0 (inclus) et la valeur maximale que vous spécifiez (exclue). Par défaut, elle retourne une valeur entre 0 et 1. C’est par conséquent utile pour choisir une valeur de `amp:` aléatoire :

    loop do
      play 60, amp: rand
      sleep 0.25
    end

## rand_i

Similaire à la relation entre `rrand_i` et `rrand`, `rand_i` retournera un nombre entier compris entre 0 et la valeur maximale que vous spécifierez.

## dice (dé)

Quelquefois, vous souhaitez émuler un jet de dé - c’est un cas particulier de `rrand_i` où la valeur minimale est toujours 1. Un appel à `dice` nécessite que vous spécifiez le nombre de faces du dé. Un dé standard a 6 faces, donc `dice(6)` agira de manière très similaire - retournant l’une des valeurs 1, 2, 3, 4, 5, ou 6. Cependant, juste comme dans des jeux de rôle, vous pourriez trouver des dés à 4 faces, ou à 12 faces, peut-être même à 120 faces !

## one_in

Finalement, vous pouvez souhaiter simuler la chance que vous avez de tomber sur le nombre le plus élevé d’un dé, soit 6 pour un dé standard. Ainsi `one_in` retourne vrai (“true”) avec une probabilité de 1 sur le nombre de faces du dé. Par conséquent `one_in(6)` retournera vrai avec une probabilité de 1 sur 6 ou faux (“false”) autrement. Les valeurs `true` et `false` sont très utiles pour les ordres `if` que nous couvrirons dans une section suivante de ce tutoriel.

Maintenant allez et introduisez de l’aléatoire dans votre code !

# 5 - Structures de programmation

Maintenant que vous avez appris les bases de la création des sons avec `play` et `sample` et la création de mélodies simples et de rythmes en utilisant `sleep` entre les sons, vous vous demandez peut-être ce que le monde du code peut vous offrir en plus…

Eh bien, vous êtes prêts pour un voyage passionnant ! Il ressort que les structures de programmation de base telles les boucles, les conditionnels, les fonctions et les fils (“threads”) vont vous procurer des outils puissants et étonnants pour exprimer vos idées musicales.

Plongeons dans les bases…

# 5.1 - Blocs

Une structure que vous verrez souvent dans Sonic Pi est le bloc. Les blocs vous permettent de faire des choses utiles avec de grands morceaux de code. Par exemple, avec les paramètres des synthés et des échantillons, nous sommes capables de changer quelque chose qui se passe sur une seule ligne. Cependant, nous souhaitons parfois faire quelque chose de significatif sur un certain nombre de lignes de code. Par exemple, nous souhaiterions les faire boucler, leur ajouter de la réverbération, les exécuter seulement une fois sur 5, etc. Considérez le code suivant :

    play 50
    sleep 0.5
    sample :elec_plip
    sleep 0.5
    play 62

Pour faire quelque chose avec un morceau de code, nous devons dire à Sonic Pi où commence le bloc et où il finit. Nous utilisons `do` pour le début et `end` pour la fin. Par exemple :

    do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Toutefois, ce n’est pas encore complet et ne fonctionnera pas (essayez-le et vous obtiendrez une erreur) puisque nous n’avons pas dit à Sonic Pi ce que nous voulions faire avec ce bloc do/end. On le dit à Sonic Pi en écrivant du code spécial avant le `do`. Nous verrons un certain nombre de ces bouts de code spéciaux plus tard dans ce tutoriel. Pour l’instant, il est important de savoir que d’encadrer votre code entre `do` et `end` dit à Sonic Pi que vous voulez faire quelque chose de spécial avec ce morceau de code.

# 5.2 - Itérations et boucles

Jusqu’à maintenant nous avons passé beaucoup de temps à rechercher les différents sons que vous pouvez faire avec des blocs de `play` et de `sample`. Nous avons aussi appris comment déclencher ces sons dans le temps en utilisant `sleep`.

Comme vous vous en êtes probablement rendu compte, on peut prendre beaucoup de plaisir avec la construction de ces blocs de base. Toutefois, une dimension totalement nouvelle de plaisir se découvre quand on commence à utiliser la puissance du code pour structurer sa musique et ses compositions. Dans les quelques sections suivantes, nous allons explorer quelques uns de ces nouveaux outils puissants. En premier, découvrons l’itération et les boucles.

## Répétition

Avez-vous écrit du code que vous aimeriez répéter quelques fois ? Par exemple, vous pourriez avoir quelque chose comme ceci :

    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25

Et si nous voulons répéter ceci 3 fois ? Eh bien, nous pourrions faire simple et juste le copier et le coller trois fois :

    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25
    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25
    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25

Maintenant, ça fait beaucoup de code ! Que se passe-t-il si nous voulions changer l’échantillon en `:elec_plip` ? Vous aller devoir trouver tous les endroits avec l’original `:elec_blup` et les modifier un par un. De façon plus importante, que faire si vous voulez répéter le bout de code original 50 fois ou 1000 fois ? Ça ferait alors vraiment beaucoup de code, et beaucoup de lignes de code à modifier si vous vouliez faire un changement.

## Itération

En fait, répéter le code devrait être aussi facile que de dire fais ceci trois fois. Eh bien, c’est presque cela. Souvenez-vous de notre vieil ami le bloc de code. Nous pouvons l’utiliser pour marquer le début et la fin du code que nous aimerions répéter trois fois. Nous utilisons alors le code spécial `3.times`. Ainsi, à la place d’écrire fais cela trois fois, nous écrivons `3.times do` - ce n’est pas trop dur. Rappelez-vous juste d’écrire `end` à la fin du code que vous devez répéter :

    3.times do
      play 50
      sleep 0.5
      sample :elec_blup
      sleep 0.5
      play 62
      sleep 0.25
    end

Alors, est-ce que ce n’est pas plus propre que de copier-coller ! Nous pouvons l’utiliser pour créer beaucoup de chouettes structures répétitives :

    4.times do
      play 50
      sleep 0.5
    end
    8.times do
      play 55, release: 0.2
      sleep 0.25
    end
    4.times do
      play 50
      sleep 0.5
    end

## Imbrication d’itérations

Nous pouvons mettre des itérations à l’intérieur d’autres itérations pour créer des motifs intéressants. Par exemple :

    4.times do
      sample :drum_heavy_kick
      2.times do
        sample :elec_blip2, rate: 2
        sleep 0.25
      end
      sample :elec_snare
      4.times do
        sample :drum_tom_mid_soft
        sleep 0.125
      end
    end

## Boucles

Si vous voulez répéter quelque chose un grand nombre de fois, vous pourriez vous trouvez en situation d’utiliser des nombres vraiment grands comme `1000.times do`. Dans ce cas, vous feriez probablement mieux de demander à Sonic Pi de répéter à l’infini (au moins jusqu’à ce que vous pressiez le bouton stop !). Bouclons l’échantillon break amen à l’infini :

    loop do
      sample :loop_amen
      sleep sample_duration :loop_amen
    end

La chose importante à savoir à propos des boucles est qu’elles se comportent comme des trous noirs pour le code. Une fois que le code est entré dans une boucle, il ne peut pas en sortir tant que vous n’avez pas pressé stop - il va juste tourner en rond dans la boucle à jamais. Ce qui signifie que si vous avez du code après la boucle, vous ne l’entendrez jamais. Par exemple, la cymbale suivant cette boucle ne sera jamais jouée :

    loop do
      play 50
      sleep 1
    end
    sample :drum_cymbal_open

Maintenant, structurez votre code avec des itérations et des boucles !

# 5.3 - Conditionnels

Une situation commune dans laquelle vous vous trouverez probablement est de non seulement jouer une note aléatoire (voir la précédente section sur l’aléatoire) mais de prendre une décision aléatoire et en fonction du résultat exécuter un code ou un autre. Par exemple, vous pourriez vouloir jouer aléatoirement un tambour ou une cymbale. Nous pouvons y parvenir avec un ordre `if` (si).

## Pile ou face

Ainsi, faisons sauter une pièce : si c’est pile, joue un tambour, si c’est face, joue une cymbale. Facile. Nous pouvons émuler le saut d’une pièce avec notre fonction `one_in` (introduite dans la section traitant de l’aléatoire) en spécifiant une probabilité de 1 sur 2 : `one_in(2)`. Nous pouvons alors en utiliser le résultat pour décider entre deux bouts de code, le code pour jouer le tambour et le code pour jouer la cymbale :

    loop do
      if one_in(2)
        sample :drum_heavy_kick
      else
        sample :drum_cymbal_closed
      end

      sleep 0.5

    end

Notez que les ordres `if` ont trois parties :

- La question à poser
- Le premier choix de code à exécuter (si la réponse à la question est oui)
- Le second choix de code à exécuter (si la réponse à la question est non)

Typiquement, dans les langages de programmation, la notion de oui est représenté par le terme `true` (vrai) et la notion de non par le terme `false` (faux). Nous avons donc besoin de trouver une question qui nous donnera une réponse `true` (“vraie”) ou `false` (“fausse”), ce qui est exactement ce que fait `one_in`.

Notez comment le premier choix est encadré entre le `if` et le `else`, et le second choix est encadré entre le `else` et le `end`. Exactement comme pour les blocs do/end, vous pouvez mettre plusieurs lignes dans chacun de ces endroits. Par exemple :

    loop do
      if one_in(2)
        sample :drum_heavy_kick
        sleep 0.5
      else
        sample :drum_cymbal_closed
        sleep 0.25
      end

    end

Cette fois nous “dormons” pour une durée différente en fonction du choix qui est fait.

## If simple

Quelquefois, nous voulons exécuter seulement une ligne de code de manière optionnelle. C’est possible en plaçant `if` à la fin et la question à la suite. Par exemple :

    use_synth :dsaw
    loop do
      play 50, amp: 0.3, release: 2
      play 53, amp: 0.3, release: 2 if one_in(2)
      play 57, amp: 0.3, release: 2 if one_in(3)
      play 60, amp: 0.3, release: 2 if one_in(4)
      sleep 1.5
    end

Ceci va jouer des accords de différents nombres avec la chance pour chaque note d’être jouée avec une probabilité différente.

# 5.4 - Threads

(“Thread” = terme technique intraduisible et dont la traduction la plus proche est “fil”.) Ainsi vous avez fait votre ligne de basse géniale et un super motif de batterie. Comment les jouer en même temps ? Une solution est de les intercaler manuellement - jouer un peu de basse, puis quelques sons de batterie, puis encore un peu de basse… Cependant, la synchronisation devient rapidement dure à concevoir, en particulier quand vous commencez à intercaler plus d’éléments.

Et si Sonic Pi pouvait vous synchroniser les choses automatiquement ? Eh bien, il le peut, et ça se fait avec une chose spéciale appelée thread.

## Boucles infinies

Pour garder cet exemple simple, vous devez imaginer que ceci est un super motif de batterie et une ligne de basse géniale :

    loop do
      sample :drum_heavy_kick
      sleep 1
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end

Comme nous en avons parlé précédemment, les boucles sont comme des trous noirs pour un programme. Dès que vous êtes entré dans une boucle, vous ne pouvez jamais en sortir à moins de presser stop. Comment pouvons-nous jouer les deux boucles en même temps ? Nous devons dire à Sonic Pi que nous voulons démarrer quelque chose en même temps que le reste du code. C’est là que les threads arrivent à la rescousse.

## Threads à la rescousse

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end

En encadrant la première boucle dans un bloc do/end `in_thread`, nous disons à Sonic Pi d’exécuter le contenu du bloc do/end exactement en même temps que l’ordre suivant le bloc do/end (qui se trouve être la seconde boucle). Essayez-le et vous entendrez à la fois la batterie et la ligne de basse synchronisées !

Maintenant, que faire si nous voulons ajouter un synthé par-dessus. Quelque chose comme :

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end
    loop do
      use_synth :zawa
      play 52, release: 2.5, phase: 2, amp: 0.5
      sleep 2
    end

Maintenant, nous avons le même problème qu’avant. La première boucle est jouée en même temps que la seconde grâce au `in_thread`. Toutefois, la troisième boucle n’est jamais atteinte. Nous avons donc besoin d’un nouveau thread :

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    in_thread do
      loop do
        use_synth :fm
        play 40, release: 0.2
        sleep 0.5
      end
    end
    loop do
      use_synth :zawa
      play 52, release: 2.5, phase: 2, amp: 0.5
      sleep 2
    end

## Les exécutions sont des threads

Ce qui peut vous surprendre est que quand vous pressez le bouton Run, vous êtes réellement en train de créer un nouveau thread pour l’exécution du code. C’est pour cela qu’en le pressant de multiples fois, vous superposerez des couches de sons les unes sur les autres. Comme les “runs” sont eux-même des threads, ils intercaleront les sons automatiquement pour vous.

## Portée

Etudiant comment maîtriser Sonic Pi, vous apprendrez que les threads sont les composants les plus importants de votre musique. L’une des responsabilités importantes qu’ils ont est d’isoler la notion de paramètres courants vis à vis des autres threads. Qu’est-ce que cela signifie ? Eh bien, quand vous commutez les synthés avec `use_synth`, vous ne commutez réellement que le synthé dans le thread courant - aucun autre thread n’aura son synthé commuté. Voyons cela en action :

    play 50
    sleep 1
    in_thread do
      use_synth :tb303
      play 50
    end
    sleep 1
    play 50

Avez-vous remarqué que le son du milieu était différent des autres ? L’ordre `use_synth` affecte uniquement le thread dans lequel il était et pas le thread extérieur principal.

## Héritage

Quand vous créez un nouveau thread avec `in_thread`, le nouveau thread hérite automatiquement de tous les paramètres courants du thread courant. Voyons cela :

    use_synth :tb303
    play 50
    sleep 1
    in_thread do
      play 55
    end

Notez que la seconde note est jouée avec le synthé `:tb303` bien qu’elle soit jouée depuis un thread distinct. Chacun des paramètres modifiés avec les différentes fonctions `use_*` se comportera exactement de la même manière.

Quand les threads sont créés, ils héritent de tous les paramètres de leur parent mais par la suite ils ne partagent plus aucun changement avec leur parent.

## Nommage des threads

Enfin nous pouvons donner des noms à nos threads :

    in_thread(name: :bass) do
      loop do
        use_synth :prophet
        play chord(:e2, :m7).choose, release: 0.6
        sleep 0.5
      end
    end
    in_thread(name: :drums) do
      loop do
        sample :elec_snare
        sleep 1
      end
    end

Regardez le panneau “trace” quand vous exécutez ce code. Voyez-vous comment la “trace” rapporte le nom du thread avec le message ?

    [Run 36, Time 4.0, Thread :bass]
     |- synth :prophet, {release: 0.6, note: 47}

## Seulement un thread autorisé par nom

Une dernière chose à savoir au sujet des threads nommés est que seul un thread d’un nom donné peut être en cours d’exécution au même moment. Explorons ceci. Considérez le code suivant :

    in_thread do
      loop do
        sample :loop_amen
        sleep sample_duration :loop_amen
      end
    end

Allez-y et collez cela dans un tampon puis pressez le bouton “Exécuter”. Pressez-le encore quelques fois. Écoutez la cacophonie des breaks amen multiples qui bouclent les uns sur les autres de façon désynchronisée. D’accord, vous pouvez maintenant presser “Arrêter”.

C’est le comportement que nous avons vu encore et encore - si vous pressez le bouton “Run”, le son s’étend au dessus de tout son existant. Donc, si vous avez une boucle et que vous pressez le bouton “Run” trois fois, vous aurez trois couches de boucles jouant simultanément.

Cependant, avec les threads nommés, c’est différent :

    in_thread(name: :amen) do
      loop do
        sample :loop_amen
        sleep sample_duration :loop_amen
      end
    end

Essayez de presser le bouton “Run” plusieurs fois avec ce code. Vous n’entendrez qu’une boucle du break amen. Vous allez aussi voir ceci dans la trace :

    ==> Sautant la création d'un thread : le thread avec le nom :amen existe déjà.

Sonic Pi vous dit qu’un thread avec le nom `:amen` est déjà en train d’être joué, donc il ne va pas en créer un autre.

Ce comportement peut ne pas vous sembler utile immédiatement - mais il sera très pratique quand nous commencerons à coder en “live”…

# 5.5 - Fonctions

Une fois que vous commencez à écrire beaucoup de code, vous pouvez souhaiter trouver le moyen d’organiser et de structurer les choses pour les rendre plus ordonnées et faciles à comprendre. Les fonctions sont un moyen très puissant pour le faire. Elles vous donnent la capacité de donner un nom à un morceau de code. Jetons-y un œil.

## Definition des fonctions

    define :foo do
      play 50
      sleep 1
      play 55
      sleep 2
    end

Ici, nous avons défini une nouvelle fonction appelée `foo`. Nous faisons cela avec notre vieil ami, le bloc do/end et le mot magique `define` suivi par le nom que nous voulons donner à notre fonction. Nous ne sommes pas tenus de l’appeler `foo`, nous aurions pu l’appeler avec n’importe quel nom que nous voulions, comme `bar`, `baz` ou idéalement quelque chose de significatif pour vous comme `section_principale` ou `lead_riff`.

Rappelez-vous d’ajouter un deux-points `:` devant le nom de votre fonction quand vous la définissez. Les noms de fonctions devraient également commencer par une lettre minuscule, donc utilisez `:foo` plutôt que `:Foo`.

## Appel des fonctions

Une fois que nous avons défini notre fonction, nous pouvons l’appeler simplement en écrivant son nom :

    define :foo do
      play 50
      sleep 1
      play 55
      sleep 0.5
    end
    foo
    sleep 1
    2.times do
      foo
    end

Nous pouvons même utiliser `foo` à l’intérieur de blocs d’itération ou n’importe où nous aurions pu écrire `play` ou `sample`. Ceci nous donne un super moyen de nous exprimer et de créer de nouveaux mots significatifs à utiliser dans nos compositions.

## Les fonctions sont mémorisées d’une exécution à l’autre

Pour le moment, chaque fois que nous avons pressé le bouton Run, Sonic Pi a démarré d’un état complètement vierge. Il ne connait rien à part ce qui est dans le buffer. Vous ne pouvez pas référencer du code d’un autre buffer ou d’un autre thread. Toutefois, les fonctions changent cela. Quand vous définissez une fonction, Sonic Pi s’en rappelle. Essayons-le. Effacez tout le code dans votre buffer et remplacez-le par :

    foo

Pressez le bouton Run et écoutez votre fonction qui est jouée. Où le code est-il allé ? Comment Sonic Pi sait-il quoi jouer ? Sonic Pi s’est simplement souvenu de votre fonction - ainsi, même après l’avoir effacée de votre buffer, il se rappelle de ce que vous avez tapé. Ce comportement fonctionne uniquement avec les fonctions créées en utilisant `define` (et `defonce`).

## Fonctions paramétrées

Vous pourriez être intéressé à savoir que juste comme vous pouvez passer les valeurs min et max à `rrand`, vous pouvez apprendre à vos fonctions à accepter des arguments. Jetons-y un œil :

    define :my_player do |n|
      play n
    end
    my_player 80
    sleep 0.5
    my_player 90

Ce n’est pas très excitant, mais ça illustre le point. Nous avons créé notre propre version de `play` appelée `my_player` et qui est paramétrée.

Les paramètres doivent être placés après le `do` du bloc do/end de `define`, entourés par des barres verticales `|` et séparés par des virgules `,`. Vous pouvez utiliser le mot de votre choix pour les noms de paramètres.

La magie se passe à l’intérieur du bloc do/end de `define`. Vous pouvez utiliser les noms de paramètres comme si c’étaient des valeurs réelles. Dans cet exemple, je joue la note `n`. Vous pouvez considérer les paramètres comme une sorte de promesse qui fait que, lorsque le code s’exécute, ils sont remplacés par des valeurs réelles. Vous faites ceci en passant un argument à la fonction quand vous l’appelez. Je le fais avec `my_player 80` pour jouer la note 80. À l’intérieur de la définition de la fonction, `n` est alors remplacé par 80, donc `play n` est changé en `play 80`. Quand je l’appelle une nouvelle fois avec `my_player 90`, `n` est alors remplacé par 90, donc `play n` est changé en `play 90`.

Voyons un exemple plus intéressant :

    define :chord_player do |root, repeats|
      repeats.times do
        play chord(root, :minor), release: 0.3
        sleep 0.5
      end
    end
    chord_player :e3, 2
    sleep 0.5
    chord_player :a3, 3
    chord_player :g3, 4
    sleep 0.5
    chord_player :e3, 3

Ici j’ai utilisé `repeats` comme si c’était un nombre dans la ligne `repeats.times do`. J’ai aussi utilisé `root` comme si c’était un nom de note dans mon appel à `play`.

Voyez comme nous sommes capables d’écrire quelque chose de très expressif et facile à lire en déplaçant beaucoup de notre logique à l’intérieur d’une fonction !

# 5.6 - Variables

Une chose utile à faire dans votre code est d’attribuer des noms aux choses. Sonic Pi rend cela très facile : vous écrivez le nom que vous voulez utiliser, un signe égal (`=`), puis la chose dont vous voulez vous rappeler :

    sample_name = :loop_amen

Ici, nous nous sommes ‘rappelés’ du symbole `:loop_amen` dans la variable `sample_name`. Nous pouvons maintenant utiliser `sample_name` partout où nous aurions utilisé `:loop_amen`. Par exemple :

    sample_name = :loop_amen
    sample sample_name

Il y a trois raisons principales pour utiliser des variables dans Sonic Pi : communication de la signification, gestion de la répétition et capture des résultats des choses.

## Communication de la signification

Quand vous écrivez du code, c’est facile de ne penser qu’à dire à l’ordinateur comment faire le boulot - tant que l’ordinateur comprend, c’est OK. Toutefois, il est important de se rappeler qu’il n’y a pas que l’ordinateur qui lit le code. D’autres personnes peuvent aussi le lire et essayer de comprendre ce qu’il fait. En outre, il est probable que vous ayez à lire votre propre code dans le futur et à essayer de comprendre ce qui s’y passe. Bien que cela puisse vous sembler évident maintenant, ce pourrait ne pas être si évident pour les autres et pour vous-même dans le futur !

Un moyen d’aider les autres à comprendre ce que fait votre code est d’écrire des commentaires (comme nous l’avons vu dans une section précédente). Une autre façon est d’utiliser des noms de variables significatifs. Regardez ce code :

    sleep 1.7533

Pourquoi utilise-t-il le nombre `1.7533` ? D’où est-il venu ? Qu’est-ce que cela signifie ? En revanche, regardez ce code :

    loop_amen_duration = 1.7533
    sleep loop_amen_duration

Maintenant, il est beaucoup plus clair que `1.7533` signifie la durée de l’échantillon `:loop_amen` ! Bien sûr, vous pourriez dire pourquoi ne pas simplement écrire :

    sleep sample_duration(:loop_amen)

Qui, bien entendu, est un moyen très sympathique de communiquer l’intention du code.

## Gestion de la répétition

Vous voyez souvent beaucoup de répétitions dans votre code et quand vous voulez changer les choses, vous devez les changer à beaucoup d’endroits. Jetez un œil à ce code :

    sample :loop_amen
    sleep sample_duration(:loop_amen)
    sample :loop_amen, rate: 0.5
    sleep sample_duration(:loop_amen, rate: 0.5)
    sample :loop_amen
    sleep sample_duration(:loop_amen)

Nous sommes en train de faire beaucoup de choses avec `:loop_amen` ! Que faire si nous voulons écouter comment ça sonne avec un autre échantillon tel que `:loop_garzul` ? Nous aurons à trouver et remplacer tous les `:loop_amen` par `:loop_garzul`. Ce ne serait pas grave si vous disposiez de beaucoup de temps - mais que faire si vous œuvrez sur scène ? Quelquefois, vous n’aurez pas le luxe de temps disponible - en particulier si vous voulez que les gens continuent à danser.

Et si vous aviez écrit votre code comme ceci :

    sample_name = :loop_amen
    sample sample_name
    sleep sample_duration(sample_name)
    sample sample_name, rate: 0.5
    sleep sample_duration(sample_name, rate: 0.5)
    sample sample_name
    sleep sample_duration(sample_name)

Maintenant, ça fait exactement la même chose qu’au dessus (essayez-le). Ça nous procure aussi la capacité de changer juste une ligne : `sample_name = :loop_amen` en `sample_name = :loop_garzul` et la magie des variables nous le change dans beaucoup d’endroits.

## Capture des résultats

Finalement, une bonne motivation pour utiliser des variables est de capturer les résultats des choses. Par exemple, vous pouvez vouloir faire des choses avec la durée d’un échantillon :

    sd = sample_duration(:loop_amen)

Nous pouvons maintenant utiliser `sd` partout où nous avons besoin de la durée de l’échantillon `:loop_amen`.

Plus important peut-être, une variable nous permet de capturer le résultat d’un appel à `play` ou `sample` :

    s = play 50, release: 8

Maintenant, nous avons capturé et mémorisé `s` comme une variable, ce qui nous permet de contrôler le synthé pendant qu’il est actif :

    s = play 50, release: 8
    sleep 2
    control s, note: 62

Nous verrons le contrôle des synthés plus en détail dans une prochaine section.

## Avertissement : variables et fils

Tandis que les variables sont géniales pour donner des noms et capturer les résultats des choses, il est important de savoir qu’elles ne doivent généralement être utilisées que localement au sein d’un fil d’exécution. Par exemple, ne faites pas ceci :

    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end

Dans l’exemple ci-dessus, nous avons assigné un anneau de nombres à la variable `a` et nous l’avons utilisé dans deux `live_loop` séparées. Dans la première boucle en direct, toutes les `0.5`s, nous trions l’anneau (à `(ring 1, 2, 3, 4, 5, 6)`) et nous l’inscrivons dans le journal. Si vous exécutez le code, vous remarquerez que la liste imprimée n’est pas toujours triée !. Cela peut vous surprendre - surtout que des fois la liste est imprimée de façon triée, et d’autres fois non. Ceci s’appelle un comportement non-déterministe et est le résultat d’un méchant problème qui s’appelle la concurrence (NdT : `race-condition`). Le problème est dû au fait que la deuxième boucle en direct manipule également la liste (pour la mélanger dans ce cas) et, au moment où la liste est imprimée, parfois elle vient d’être triée, et d’autres fois, elle vient d’être mélangée. Les deux boucles en direct se font concurrence pour faire une manipulation différente à la même variable et, à chaque itération, une boucle différente “gagne”.

Il y a deux solutions à cela. Premièrement, n’utilisez pas la même variable dans de multiples boucles en direct ou fil d’exécution. Par exemple, le code suivant imprimera toujours une liste triée puisque chaque boucle en direct possède ses propres variables séparées :

    live_loop :shuffled do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

Par contre, parfois nous voulons partager des éléments entre plusieurs fils d’exécution. Par exemple, la clé courante, BPM, synthé etc. Dans ces cas, la solution est d’utiliser le système d’état de fil d’exécution sécurisé spécial de Sonic Pi par les fonctions `get` et `set`. Nous en reparlons dans la section 10.

# 5.7 - Synchronisation des threads

Une fois que vous êtes suffisamment avancés en codage “live” avec un certain nombre de fonctions et de threads en simultanéité, vous avez probablement remarqué que c’est plutôt facile de faire une faute dans l’un des threads et qui lui met fin. Ce n’est pas un gros problème car vous pouvez facilement redémarrer le thread en pressant Run. Toutefois, quand vous redémarrez le thread, il se trouve alors déphasé avec les threads d’origine.

## Temps hérité

Comme nous en avons discuté auparavant, les nouveaux threads créés avec `in_thread` héritent de tous les paramètres du thread parent. Ceci inclut l’heure actuelle. Ce qui signifie que les threads sont toujours en phase entre eux quand ils sont démarrés simultanément.

Toutefois quand vous démarrez un thread tout seul, il démarre avec sa propre heure qui n’est probablement en phase avec aucun des autres threads en cours d’exécution.

## Cue et sync

Sonic Pi fournit une solution à ce problème avec les fonctions `cue` et `sync`.

`cue` nous permet d’envoyer nos messages de battement de cœur à tous les autres threads. Par défaut, les autres threads ne sont pas intéressés et ignorent ces messages de battement de coeur. Cependant, vous pouvez leur déclarer de l’intérêt avec la fonction `sync`.

La chose importante à laquelle il faut être attentif est que `sync` est similaire à `sleep` dans le sens qu’elle arrête le thread courant et l’empêche de faire quoi que ce soit pendant un moment. Toutefois, avec `sleep`, vous spécifiez combien de temps vous voulez attendre tandis qu’avec `sync`, vous ne savez pas combien de temps vous allez attendre - étant donné que `sync` attend le `cue` suivant d’un autre thread, ce qui peut être court ou long.

Explorons ceci en un peu plus de détail :

    in_thread do
      loop do
        cue :tick
        sleep 1
      end
    end
    in_thread do
      loop do
        sync :tick
        sample :drum_heavy_kick
      end
    end

Nous avons ici deux threads - l’un agissant comme un métronome, ne jouant aucun son mais envoyant des messages de battement de cœur `:tick` à chaque temps. Le second thread se synchronise sur les messages `tick` et quand il en reçoit un, il hérite de l’heure du thread `cue` et continue de jouer.

Par conséquent, nous entendons l’échantillon `:drum_heavy_kick` exactement quand l’autre thread envoie le message `:tick`, même si les deux threads n’ont pas démarré leur exécution en même temps :

    in_thread do
      loop do
        cue :tick
        sleep 1
      end
    end
    sleep(0.3)
    in_thread do
      loop do
        sync :tick
        sample :drum_heavy_kick
      end
    end

Ce vilain appel à `sleep` mettrait typiquement le second thread en déphasage avec le premier. Cependant, comme nous utilisons `cue` et `sync`, nous synchronisons automatiquement les threads en évitant un décalage de temps accidentel.

## Noms des “cue”

Vous êtes libre d’utiliser n’importe quel nom que vous aimeriez pour vos messages `cue`, pas seulement `:tick`. Vous devez juste vous assurer que tout autre thread se synchronise sur le bon nom - autrement il attendrait à jamais (au moins jusqu’à ce que vous pressiez le bouton Stop).

Jouons avec quelques noms de `cue` :

    in_thread do
      loop do
        cue [:foo, :bar, :baz].choose
        sleep 0.5
      end
    end
    in_thread do
      loop do
        sync :foo
        sample :elec_beep
      end
    end
    in_thread do
      loop do
        sync :bar
        sample :elec_flip
      end
    end
    in_thread do
      loop do
        sync :baz
        sample :elec_blup
      end
    end

Ici, nous avons une boucle principale `cue` qui envoie aléatoirement un des battements de cœur nommés `:foo`, `:bar` ou `:baz`. Nous avons aussi ensuite trois boucles en thread se synchronisant sur ces noms indépendamment et jouant un échantillon différent. Il est clair que nous entendons un son à chaque demi-temps puisque chacun des threads `sync` est aléatoirement synchronisé avec le thread `cue` et joue son échantillon.

Ceci, bien entendu, marche aussi si vous ordonnez les threads en sens inverse puisque les threads `sync` restent en attente du `cue` suivant.

# 6 - Studio FX (effets de studio)

Un des aspects les plus gratifiants et sympathiques de Sonic Pi est la capacité d’ajouter des effets de studio à vos sons. Par exemple, vous pouvez vouloir ajouter de la réverbération à des parties de votre œuvre, ou de l’écho ou peut-être même de la distorsion ou du trémolo à vos lignes de basse.

Sonic Pi fournit un moyen très simple mais cependant puissant pour ajouter des effets (FX). Il vous autorise même à les chaîner (ainsi vous pouvez passer vos sons dans la distorsion, puis dans l’écho, puis dans la réverbération) et aussi à contrôler chaque unité FX individuellement avec des options (d’une façon similaire à la spécification des paramètres pour les synthés et les échantillons). Vous pouvez même modifier les options d’un FX pendant qu’il est encore en train d’agir. Ainsi, par exemple, vous pouvez augmenter la réverbération de vos basses tout au long de la piste…

## Pédales de guitare

Si tout ceci paraît un tantinet compliqué, ne vous inquiétez pas. Une fois que vous aurez joué un peu avec, tout deviendra complètement clair. Avant qu’il en soit ainsi, faisons une simple analogie avec des pédales d’effets de guitare. Il y a des tas de sortes de pédales d’effets que vous pouvez acheter. Certaines ajoutent de la réverbération, d’autres de la distorsion, etc. Un guitariste va brancher sa guitare à une pédale d’effets - de distorsion par exemple - puis prendre un autre câble pour lui connecter (chaîner) une pédale de réverbération. La sortie de la pédale de réverbération pourra alors être branchée à l’amplificateur :

    Guitare -> Distorsion -> Réverbération -> Amplificateur

Cela s’appelle le chaînage des effets. Sonic Pi supporte exactement cela. De plus, chaque pédale a souvent des molettes et des curseurs pour vous permettre de contrôler le niveau de la distorsion, de la réverbération, de l’écho, etc. à appliquer. Sonic Pi supporte aussi ce type de contrôle. Finalement, vous pouvez imaginer un guitariste qui joue pendant que quelqu’un d’autre modifie les contrôles d’effets de la pédale. Sonic Pi supporte aussi cela - mais au lieu d’avoir besoin de quelqu’un d’autre pour contrôler les choses pour vous, c’est l’ordinateur qui s’en charge.

Explorons les effets !

# 6.1 - Ajout d’effets (FX)

Dans cette section, nous allons regarder un couple d’effets : réverbération et écho. Nous allons voir comment les utiliser, comment contrôler leurs options et comment les chaîner.

Le système d’effets de Sonic Pi utilise les blocs. Donc, si vous n’avez pas lu la section 5.1, vous pourriez lui jeter un œil rapidement et puis revenir ici.

## Réverbération

Si nous voulons utiliser la réverbération, nous écrivons `with_fx :reverb` en tant qu’entête particulière de notre bloc, comme ceci :

    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Maintenant exécutez ce code et vous l’entendrez joué avec réverbération. Ça sonne bien, n’est-ce pas ! Tout sonne plutôt agréablement avec de la réverbération.

Maintenant, voyons ce qui se passe si nous avons du code en dehors du bloc do/end :

    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end
    sleep 1
    play 55

Remarquez que le dernier `play 55` n’est pas joué avec de la réverbération. C’est parce qu’il est en dehors du bloc do/end, ainsi l’effet de réverbération n’agit pas sur lui.

De même, si vous placez des sons avant le bloc do/end, ils ne seront pas non plus affectés :

    play 55
    sleep 1
    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end
    sleep 1
    play 55

## Écho

Il y a beaucoup de choix d’effets. Et si on essayait un peu d’écho ?

    with_fx :echo do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Un des puissants aspects des blocs d’effets de Sonic Pi est qu’on peut leur passer des options de manière similaire aux options que nous avons déjà vues avec `play` et `sample`. Par exemple, un paramètre sympa d’écho avec lequel jouer est `phase:`. Il représente la durée d’un écho en temps musicaux. Rendons l’écho plus lent :

    with_fx :echo, phase: 0.5 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Rendons aussi l’écho plus rapide :

    with_fx :echo, phase: 0.125 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Faisons décroître l’écho plus longuement en spécifiant la durée de `decay:` à 8 temps :

    with_fx :echo, phase: 0.5, decay: 8 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

## Imbrication des effets

Un des aspects les plus puissants des blocs d’effets est que vous pouvez les imbriquer. Ceci vous permet de chaîner facilement les effets entre eux. Par exemple, que faire si vous vouliez jouer du code avec de l’écho et ensuite de la réverbération ? Facile, mettez simplement l’un à l’intérieur de l’autre :

    with_fx :reverb do
      with_fx :echo, phase: 0.5, decay: 8 do
        play 50
        sleep 0.5
        sample :elec_blup
        sleep 0.5
        play 62
      end
    end

Pensez à du son provenant de l’intérieur et se propageant vers l’extérieur. Le son de tout le code situé dans le bloc intérieur dont `play 50` est d’abord envoyé vers l’effet d’écho et le son produit par l’effet d’écho est à son tour envoyé vers l’effet de réverbération.

Nous pouvons utiliser des imbrications très profondes pour une large gamme de résultats délirants. Toutefois, soyez averti, les effets peuvent utiliser beaucoup de ressources et quand vous les imbriquez, vous allez effectivement faire agir de multiples effets simultanément. Donc soyez économe avec l’utilisation des FX, en particulier sur des plateformes peu puissantes telles que le Raspberry Pi.

## À la découverte des effets

Sonic Pi est livré avec un grand nombre d’effets avec lesquels vous pouvez jouer. Pour trouver ceux qui sont disponibles, cliquez sur “FX” dans le menu horizontal du système d’aide et vous verrez une liste des options disponibles. Voici une liste de mes préférés :

- wobble,
- reverb,
- echo,
- distortion,
- slicer

Maintenant, défoulez-vous et ajoutez des effets partout pour obtenir d’étonnants sons nouveaux !

# 6.2 - FX en pratique

Bien qu’ils paraissent trompeusement simples extérieurement, les FX sont en fait des bêtes plutôt complexes à l’intérieur. Leur simplicité incite souvent les gens à en abuser dans leurs morceaux. Cela ne sera peut-être pas gênant si vous avez une machine puissante, mais si - comme moi - vous utilisez un Raspberry Pi pour improviser, vous devez prendre garde à la somme de travail que vous lui demandez de faire si vous voulez vous assurer que la cadence reste fluide.

Considérez ce code :

    loop do
      with_fx :reverb do
        play 60, release: 0.1
        sleep 0.125
      end
    end

Dans ce code, nous jouons la note 60 avec une durée d’extinction très courte, c’est donc une note courte. Nous voulons aussi de la réverbération, alors nous l’avons imbriqué dans un bloc de réverbération. Jusqu’à maintenant, tout est bon. Sauf que…

Regardons ce que fait le code. En premier lieu, nous avons une boucle (`loop`), ce qui signifie que tout ce qui est à l’intérieur est répété sans fin. Ensuite, nous avons un bloc `with_fx`. Ceci veut dire que nous allons créer un nouvel FX de réverbération chaque fois que nous bouclons. C’est comme si nous disposions d’une pédale de réverbération distincte à chaque fois que nous pincions une corde sur une guitare. C’est super de pouvoir faire ça, mais ce n’est pas toujours ce que vous voulez. Par exemple, ce code va avoir du mal à s’exécuter comme il faut sur un Raspberry Pi. Tout le travail de création de la réverbération puis d’attente jusqu’à ce qu’elle doive être stoppée et enlevée est complètement pris en charge par `with_fx` pour vous, mais ceci prend de la puissance du microprocesseur (CPU) qui peut être précieuse.

Comment le faire d’une manière plus proche d’une installation traditionnelle où notre guitariste n’a qu’une pédale de réverbération dans laquelle passent tous les sons ? Simple :

    with_fx :reverb do
      loop do
        play 60, release: 0.1
        sleep 0.125
      end
    end

Nous mettons notre boucle à l’intérieur du bloc `with_fx`. De cette façon, nous créons seulement une unique réverbération pour toutes les notes jouées dans notre boucle. Ce code est beaucoup plus efficace et fonctionnerait bien sur un Raspberry Pi.

Un compromis est d’utiliser `with_fx` sur une itération à l’intérieur d’une boucle :

    loop do
      with_fx :reverb do
        16.times do
          play 60, release: 0.1
          sleep 0.125
        end
      end
    end

De cette façon, nous avons remonté le `with_fx` en dehors de la partie la plus intérieure de la boucle, et nous créons maintenant une nouvelle réverbération toutes les 16 notes.

C’est quelque chose que l’on fait si souvent que `with_fx` supporte une option pour faire exactement cela sans devoir écrire le bloc `16.times` :

    loop do
      with_fx :reverb, reps: 16 do
        play 60, release: 0.1
        sleep 0.125
      end
    end

Les deux exemples `reps: 16` et `16.times do` se comporteront de la même manière. L’exemple avec `reps: 16` répète en fait le code dans le bloc `do/end` seize fois donc vous pouvez choisir l’un ou l’autre en fonction de vos préférences.

Rappelez-vous, il n’y a pas de fautes, juste des possibilités. Toutefois, certaines de ces approches donneront un son différent et auront des caractéristiques de performance différentes. Donc, jouez et utilisez l’approche qui sonne le mieux pour vous tout en restant dans les contraintes de performance de votre plateforme.

# 7 - Contrôle des sons en cours d’écoute

Pour l’instant, nous avons regardé comment déclencher des sons de synthé et des échantillons, et aussi comment changer leurs paramètres par défaut comme l’amplitude, la balance, les paramètres d’enveloppe, et davantage. Chaque son émis est essentiellement son propre son avec son propre ensemble de paramètres fixés pour la durée du son.

Ne serait-ce pas sympathique si nous pouvions changer les paramètres d’un son pendant qu’il est encore en train d’être joué, tout comme vous pourriez tendre une corde de guitare pendant qu’elle est en train de vibrer ?

Vous avez de la chance - cette section va vous montrer précisément comment le faire.

# 7.1 - Contrôler des synthés en train de jouer

Pour l’instant, nous nous sommes seulement préoccupés de déclencher de nouveaux sons et effets (FX). Toutefois, Sonic Pi nous offre la capacité de manipuler et de contrôler les sons pendant qu’il sont joués. Nous le faisons en utilisant une variable pour mémoriser la référence à un synthé :

    s = play 60, release: 5

Ici, nous avons une variable locale à l’exécution `s` qui représente le synthé jouant la note 60. Notez que c’est local à l’exécution - vous ne pouvez pas y accéder depuis d’autres exécutions comme les fonctions.

Une fois que nous avons `s`, nous pouvons commencer à la contrôler via la fonction `control` :

    s = play 60, release: 5
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

La chose à remarquer est que nous ne sommes pas en train de déclencher 4 synthés différents ici - nous en déclenchons seulement un et puis nous changeons ensuite 3 fois la hauteur, pendant qu’il joue.

Nous pouvons passer n’importe quel paramètre standard à `control`, vous pouvez donc contrôler des choses telles que `amp:`, `cutoff:` ou `pan`.

## Paramètres non contrôlables

Quelques paramètres ne peuvent pas être contrôlés une fois que le synthé joue. C’est le cas pour tous les paramètres d’enveloppe ADSR. Vous pouvez trouver quels paramètres sont contrôlables en regardant leur documentation dans le système d’aide. Si la documentation dit Can not be changed once set (ne peut être modifié une fois attribué), vous savez que ce n’est pas possible de contrôler le paramètre après que le synthé ait commencé à jouer.

# 7.2 - Contrôle des effets (FX)

Il est aussi possible de contrôler les FX, bien que ce soit accompli d’une manière légèrement différente :

    with_fx :reverb do |r|
      play 50
      sleep 0.5
      control r, mix: 0.7
      play 55
      sleep 1
      control r, mix: 0.9
      sleep 1
      play 62
    end

Au lieu d’utiliser une variable, nous utilisons le paramètre cible d’un bloc do/end. À l’intérieur des barres verticales `|`, nous devons attribuer un nom unique à notre FX en cours, nom que nous référençons alors depuis l’intérieur du bloc do/end. Ce comportement est identique à celui d’utiliser des fonctions paramétrées.

Maintenant, allez et contrôlez des synthés et des FX !

# 7.3 - Paramètres à curseur glissant

Pendant l’exploration des paramètres des synthés et des FX, vous pourriez avoir remarqué qu’il y a un certain nombre de paramètres finissant par `_slide`. Vous avez peut-être même essayé de les appeler et n’avez constaté aucun effet. C’est parce que ce ne sont pas des paramètres normaux, ce sont des paramètres spéciaux qui n’agissent que quand vous contrôlez les synthés comme cela est décrit dans la section précédente.

Considérez l’exemple suivant :

    s = play 60, release: 5
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

Ici, vous pouvez entendre la hauteur du son changer instantanément après l’appel à `control`. Toutefois, nous pourrions souhaiter que la hauteur glisse entre les changements. Comme nous sommes en train de contrôler le paramètre `note:`, pour ajouter un glissement, nous devons fixer le paramètre `note_slide` du synthé :

    s = play 60, release: 5, note_slide: 1
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

Maintenant, nous entendons la hauteur des notes glisser entre les appels à `control`. Ça sonne agréable, n’est-ce pas ? Vous pouvez accélérer le glissement en utilisant une durée plus courte comme `note_slide: 0.2` ou le ralentir en utilisant une durée de glissement plus longue.

Chaque paramètre qui peut être contrôlé a un paramètre correspondant avec `_slide` à votre disposition.

## Le glissement est rémanent

Une fois que vous avez fixé un paramètre `_slide` à un synthé en cours de jeu, il sera mémorisé et appliqué à chaque fois que le paramètre correspondant sera utilisé. Pour arrêter le glissement, vous devez fixer la valeur de `_slide` à 0 avant l’appel suivant à `control`.

## Paramètres FX à curseur glissant

Il est aussi possible de faire glisser les paramètres FX :

    with_fx :wobble, phase: 1, phase_slide: 5 do |e|
      use_synth :dsaw
      play 50, release: 5
      control e, phase: 0.025
    end

Maintenant ayez du plaisir à faire glisser les choses pour obtenir des transitions douces et un contrôle fluide…

# 8 - Structures de données

Un outil très utile dans la boîte à outils d’un programmeur est une structure de données.

Quelque fois, vous souhaiteriez représenter et utiliser plus d’une seule chose à la fois. Vous pourriez trouver utile de disposer d’une série de notes à jouer l’une après l’autre. Les langages de programmation offrent des structures de données pour autoriser précisément ceci.

Il y a beaucoup de structures de données passionnantes et exotiques à la disposition des programmeurs - et on en invente toujours de nouvelles. Cependant, pour l’instant nous avons seulement réellement besoin de nous intéresser à une structure de données très simple - la liste.

Regardons-la de manière plus détaillée. Nous allons décrire sa forme basique et ensuite montrer comment l’utiliser pour représenter des gammes et des accords.

# 8.1 - Listes

Dans cette section, nous allons voir une structure de données qui est très utile - la liste. Nous l’avons rencontrée brièvement auparavant dans la section sur l’aléatoire quand nous choisissions aléatoirement des notes à jouer dans une liste :

    play choose([50, 55, 62])

Dans cette section, nous allons explorer l’utilisation des listes également pour représenter des accords et des gammes. En premier lieu, récapitulons comment nous jouerions un accord. Souvenez-vous que si nous n’utilisons pas `sleep`, les sons arrivent tous au même moment :

    play 52
    play 55
    play 59

Regardons d’autres façons d’écrire ce code.

## Jeu d’une liste

Une option est de placer toutes les notes dans une liste : `[52, 55, 59]`. Notre sympathique fonction `play` est assez évoluée pour savoir comment jouer une liste de notes. Essayez-le :

    play [52, 55, 59]

Ooh, c’est déjà plus agréable à lire. Jouer une liste de notes ne vous empêche pas d’utiliser normalement n’importe quel paramètre des spécifications :

    play [52, 55, 59], amp: 0.3

Bien sûr, vous pouvez aussi utiliser les noms traditionnels des notes (en notation anglaise) à la place des nombres de la norme MIDI :

    play [:E3, :G3, :B3]

Maintenant, ceux qui sont assez chanceux pour avoir étudié quelques notions de solfège, pourraient reconnaître l’accord de Mi mineur joué à la 3ème octave.

## Accès à une liste

Une autre caractéristique très utile d’une liste est d’en extraire de l’information. Ceci peut paraître étrange, mais ce n’est pas plus compliqué que de tourner les pages d’un livre jusqu’à la page 23. Avec une liste, vous diriez : quel est l’élément à l’index 23 ? La seule chose étrange est qu’en programmation, les index commencent généralement à 0 et non pas 1.

Avec les index d’une liste, nous ne comptons pas 1, 2, 3… mais 0, 1, 2…

Regardons ceci en un peu plus de détails. Jetez un œil sur cette liste :

    [52, 55, 59]

Il n’y a rien là de particulièrement effrayant. Maintenant, quel est le second élément de la liste ? Oui, bien sûr, c’est `55`. C’était facile. Regardons si nous pouvons obtenir la réponse de l’ordinateur :

    puts [52, 55, 59][1]

OK, ça semble un peu bizarre si vous n’avez jamais vu quelque chose de la sorte auparavant. Faites-moi confiance toutefois, ce n’est pas trop dur. Il y a trois parties dans la ligne ci-dessus : le mot `puts`, notre liste `52, 55, 59` et notre index `[1]`. En premier, nous disons `puts` parce que nous voulons que Sonic Pi nous affiche la réponse dans le panneau “trace”. Ensuite, nous lui donnons notre liste, et enfin notre index qui demande le second élément. Nous devons encadrer notre index avec des crochets et parce que le compte commence à 0, l’index pour le second élément est `1`. Regardez :

    # index :  0   1   2
              [52, 55, 59]

Essayez d’exécuter le code `puts [52, 55, 59][1]` et vous verrez `55` apparaître dans le panneau “trace”. Changez l’index `1` par d’autres valeurs, essayez des listes plus longues et pensez à la façon dont vous pourriez utiliser une liste dans votre prochaine improvisation avec du code. Par exemple, quelles structures musicales pourraient être représentées par une série de nombres…

# 8.2 - Accords

Sonic Pi incorpore le support des noms d’accord, lequel retourne des listes. Essayez-le vous-même :

    play chord(:E3, :minor)

Maintenant, nous avons vraiment progressé. Ça parait beaucoup plus joli que les listes brutes (et c’est plus facile à lire pour les autres). Alors quels autres accords Sonic Pi supporte-t-il ? Eh bien, un tas. Essayez quelques-uns parmi ceux-ci :

- `chord(:E3, :m7)`
- `chord(:E3, :minor)`
- `chord(:E3, :dim7)`
- `chord(:E3, :dom7)`

## Arpèges

Nous pouvons facilement changer les accords en arpèges avec la fonction `play_pattern` :

    play_pattern chord(:E3, :m7)

OK, ce n’est pas très marrant - ça le joue vraiment lentement. `play_pattern` va jouer chaque note de la liste avec un appel à `sleep 1` entre chaque appel à `play`. Nous pouvons utiliser une autre fonction `play_pattern_timed` pour spécifier nos propres durées et accélérer les choses :

    play_pattern_timed chord(:E3, :m7), 0.25

Nous pouvons même passer une liste de durées qui sera traitée de façon circulaire :

    play_pattern_timed chord(:E3, :m13), [0.25, 0.5]

Ceci est équivalent à :

    play 52, sustain: 0.25
    sleep 0.25
    play 55, sustain: 0.5
    sleep 0.5
    play 59, sustain: 0.25
    sleep 0.25
    play 62, sustain: 0.5
    sleep 0.5
    play 66, sustain: 0.25
    sleep 0.25
    play 69, sustain: 0.5
    sleep 0.5
    play 73, sustain: 0.25
    sleep 0.25

Lequel préféreriez-vous écrire ?

Notez que `play_pattern` et `play_pattern_timed` modifient le sustain des notes pour remplir les temps. Vous pouvez supprimer ce comportement en paramétrant l’option `sustain:` à `0` :

    play_pattern_timed chord(:E3, :m13), [0.25, 0.5], sustain: 0

# 8.3 - Gammes

Sonic Pi supporte un large éventail de gammes. Comment faire pour jouer une gamme majeure de Do3 (C3) ?

    play_pattern_timed scale(:c3, :major), 0.125, release: 0.1

Nous pouvons même demander davantage d’octaves :

    play_pattern_timed scale(:c3, :major, num_octaves: 3), 0.125, release: 0.1

Comment obtenir toutes les notes d’une gamme pentatonique ?

    play_pattern_timed scale(:c3, :major_pentatonic, num_octaves: 3), 0.125, release: 0.1

## Notes aléatoires

Les accords et les gammes sont des bons moyens de contraindre un choix aléatoire à quelque chose de significatif. Jouez un instant avec cet exemple qui prend des notes aléatoirement dans l’accord mineur de Mi3 :

    use_synth :tb303
    loop do
      play choose(chord(:E3, :minor)), release: 0.3, cutoff: rrand(60, 120)
      sleep 0.25
    end

Essayez de modifier cet exemple avec quelques noms d’accords différents et des plages de “cutoff” différentes.

## Découverte des accords et des gammes

Pour découvrir quelles gammes et quels accords sont supportés par Sonic Pi, cliquez sur le bouton “Lang” du menu horizontal à gauche de ce tutoriel, et choisissez soit “chord” (accord) ou “scale” (gamme) dans la liste du dessus. Dans le panneau d’information, faites défiler l’affichage vers le bas jusqu’à voir une longue liste d’accords ou de gammes (selon lequel des deux vous regardez).

Faites-vous plaisir et rappelez-vous : il n’y a pas de fautes, que des opportunités.

# 8.4 - Anneaux

Les anneaux sont une variation intéressante des listes classiques. Si vous avez quelques connaissances en programmation, vous pouvez avoir eu affaire aux “ring buffers” ou aux “ring arrays”. Ici, nous allons juste voir les “rings” - c’est court et simple.

Dans la section précédente sur les listes, nous avons vu comment nous pouvions aller en chercher des éléments en utilisant le mécanisme d’indexage :

    puts [52, 55, 59][1]

Maintenant, qu’arrive-t-il si vous voulez l’index `100` ? Eh bien, c’est clair qu’il n’y a pas d’élément à l’index 100 puisque la liste ne contient que trois éléments. Alors Sonic Pi retournera `nil` ce qui veut dire “rien”.

Maintenant, imaginons que nous ayons un compteur tel que celui des temps musicaux qui s’incrémente continuellement. Créons notre compteur et notre liste :

    counter = 0
    notes = [52, 55, 59]

Nous pouvons maintenant utiliser notre compteur pour accéder à une note de notre liste :

    puts notes[counter]

Super, nous avons obtenu `52`. Maintenant, incrémentons notre compteur et obtenons une autre note :

    counter = (inc counter)
    puts notes[counter]

Super, nous obtenons maintenant `55` et si nous le faisons une nouvelle fois, nous obtenons `59`. Toutefois, si nous le faisons encore une nouvelle fois, nous allons nous trouver en dehors des nombres de notre liste et obtenir `nil`. Que faire si nous voulions juste boucler en revenant en arrière et recommencer au début de la liste ? C’est pour cela que les anneaux (“rings”) sont faits.

## Création des anneaux

Nous pouvons créer des anneaux de deux façons. Ou bien nous utilisons la fonction `ring` avec les éléments de l’anneau comme paramètres :

    (ring 52, 55, 59)

Ou bien nous pouvons prendre une liste normale et la convertir en anneau en lui envoyant le message `.ring` :

    [52, 55, 59].ring

## Indexation des anneaux

Une fois que nous avons un anneau, nous pouvons l’utiliser de la même manière que nous utiliserions une liste normale avec l’exception que nous pouvons utiliser des index négatifs ou des index qui sont plus grands que la taille de l’anneau, et ils vont boucler tout autour pour toujours pointer sur un des éléments de l’anneau :

    (ring 52, 55, 59)[0] #=> 52
    (ring 52, 55, 59)[1] #=> 55
    (ring 52, 55, 59)[2] #=> 59
    (ring 52, 55, 59)[3] #=> 52
    (ring 52, 55, 59)[-1] #=> 59

## Utilisation des anneaux

Supposons que nous utilisons une variable pour représenter le numéro de battement courant. Nous pouvons l’utiliser comme un index de notre anneau pour aller chercher les notes à jouer, ou les durées d’extinction ou n’importe quelle chose utile que nous avons mémorisée dans notre anneau sans se préoccuper de la valeur du numéro de battement en cours.

## Les gammes et les accords sont des anneaux

Une chose utile à savoir est que les listes retournées par `scale` et `chord` sont aussi des anneaux et cela vous permet d’y accéder avec des valeurs d’index arbitraires.

## Constructeurs d’anneaux

En plus de `ring`, il y a un certain nombre de fonctions qui vous construiront un anneau.

- `range` vous invite à spécifier un point de départ, un point de fin, et la taille du pas.
- `bools` vous permet d’utiliser des `1` et des `0` pour représenter les booléens de manière condensée.
- `knit` vous permet de créer une séquence de valeurs dupliquées.
- `spread` crée un anneau de booléens avec une distribution euclidienne.

Jetez un œil à leur documentation respective pour plus d’informations.

# 8.5 - Chaînes d’anneaux

En plus des constructeurs comme `range` et `spread`, une autre façon de créer de nouveaux anneaux est de manipuler des anneaux existants.

## Commandes de chaîne

Pour explorer ceci, prenons un anneau simple :

    (ring 10, 20, 30, 40, 50)

Et si on voulait son inverse ? Eh bien on utiliserait la commande de chaîne `.reverse` pour prendre l’anneau et l’inverser :

    (ring 10, 20, 30, 40, 50).reverse  #=> (ring 50, 40, 30, 20, 10)

Et si on voulait les trois premières valeurs de l’anneau ?

    (ring 10, 20, 30, 40, 50).take(3)  #=> (ring 10, 20, 30)

Finalement, et si on voulait mélanger l’anneau ?

    (ring 10, 20, 30, 40, 50).shuffle  #=> (ring 40, 30, 10, 50, 20)

## Chaînes multiples

C’est déjà une manière puissante de créer de nouveaux anneaux. Ceci dit la vraie puissance vient quand on enchaîne quelques-unes de ces commandes à la suite.

Et si on mélangeait l’anneau, on lâchait un élément puis on en prenait les trois suivants ?

Regardons ceci par étapes :

1. `(ring 10, 20, 30, 40, 50)` - notre anneau initial
2. `(ring 10, 20, 30, 40, 50).shuffle` - mélange - `(ring 40, 30, 10, 50, 20)`
3. `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - en lâche un - `(ring 30, 10, 50, 20)`
4. `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - en prend trois - `(ring 30, 10, 50)`

Vous voyez comme on peut créer une longue chaîne de ces méthodes juste en les collant à la suite. On peut les combiner dans l’ordre qu’on veut, ce qui crée une manière extrêmement riche et puissante de générer de nouveaux anneaux à partir d’anneaux existants.

## Immutabilité

Ces anneaux ont une propriété puissante et importante. Ils sont immutables, ce qui veut dire qu’ils ne peuvent pas changer. Cela veut dire que les méthodes de chaînage décrites dans cette section ne modifient pas les anneaux, elles en créent plutôt de nouveaux. Cela veut dire que vous êtes libres de partager des anneaux entre les threads et de les chaîner dans un thread en sachant que vous n’affecterez aucun autre thread qui utilise le même anneau.

## Méthodes de chaîne disponibles

Voici une liste des méthodes de chaîne disponibles :

- `.reverse` - retourne une version inversée de l’anneau
- `.sort` - crée une version triée de l’anneau
- `.shuffle` - crée une version mélangée de l’anneau
- `.pick` - retourne un anneau avec le résultat d’un appel à `.choose` une fois
- `.pick(3)` - retourne un anneau avec le résultat de trois appels à `.choose`
- `.take(5)` - retourne un nouvel anneau contenant uniquement les cinq premiers éléments
- `.drop(3)` - retourne un nouvel anneau avec tout sauf les trois premiers éléments
- `.butlast` - retourne un nouvel anneau sans le dernier élément
- `.drop_last(3)` - retourne un nouvel anneau sans les trois derniers éléments
- `.take_last(6)`- retourne un nouvel anneau avec les six derniers éléments seulement
- `.stretch(2)` - répète chaque élément dans l’anneau deux fois
- `.repeat(3)` - répète l’anneau entier trois fois
- `.mirror` - ajoute l’anneau à une version inversée de lui-même
- `.reflect` - comme `.mirror` mais sans dupliquer la valeur du milieu
- `.scale(2)` - retourne un nouvel anneau avec tous les éléments multipliés par 2 (l’anneau doit contenir uniquement des nombres)

Évidemment, les méthodes de chaîne qui prennent des nombres peuvent prendre d’autres nombres aussi ! N’hésitez donc pas à appeler `.drop(5)` au lieu de `.drop(3)` si vous voulez lâcher les cinq premiers éléments.

# 9 - Programmation interactive (Live Coding)

Un des aspects les plus passionnants de Sonic Pi est qu’il vous permet d’écrire et de modifier du code en direct pour faire de la musique, juste comme vous le feriez avec une guitare. Un avantage de cette approche est qu’il vous procure plus de retour d’informations pendant que vous composez (avoir une simple boucle en cours d’exécution et continuer à l’ajuster jusqu’à qu’elle sonne parfaitement). Cependant, le principal avantage est que vous pouvez amener Sonic Pi sur scène et donner un concert avec.

Dans cette section, nous allons couvrir les fondamentaux du changement de vos compositions avec du code statique en interprétations dynamiques.

Tenez-vous bien…

# 9.1 - Programmation interactive (Live Coding)

Maintenant nous en avons suffisamment appris pour commencer réellement à prendre du plaisir. Dans cette section, nous allons mettre en pratique toutes les sections précédentes et vous montrer comment commencer à faire vos compositions musicales en direct et les transformer en performance. Pour cela, nous aurons besoin de trois ingrédients principaux :

- Une capacité à écrire du code qui produit des sons - C’est fait !
- Une capacité à écrire des fonctions - C’est fait !
- Une capacité à utiliser des threads (nommés) - C’est fait !

D’accord, allons-y. Codons en direct nos premiers sons. En premier lieu, nous avons besoin d’une fonction contenant le code que nous voulons jouer. Commençons simple. Nous voulons aussi une boucle d’appels à cette fonction dans un fil d’exécution :

    define :my_sound do
      play 50
      sleep 1
    end
    in_thread(name: :looper) do
      loop do
        my_sound
      end
    end

Si ça vous semble un petit peu trop compliqué, revenez en arrière et relisez les sections sur les fonctions et les threads. Ce n’est pas trop compliqué si vous avez déjà emmagasiné ces choses dans votre tête.

Ici nous avons une définition de fonction qui joue juste la note 50 et qui dort pendant un temps. Nous définissons ensuite un thread avec le nom `:looper` qui joue en boucle, il “boucle”, en appelant `my_loop` de manière répétitive.

Si vous exécutez ce code, vous entendrez la note 50 répétée encore et encore…

## Modifions-le

Maintenant, c’est là que le plaisir commence. Pendant que le code est encore en cours d’exécution changez 50 en un autre nombre, disons 55, ensuite pressez le bouton Exécuter une nouvelle fois. Woah ! C’est modifié ! En direct !

Une nouvelle couche n’a pas été ajoutée parce que nous utilisons des threads nommés et que seul un thread est permis pour chaque nom. De plus, le son a changé parce que nous avons redéfini la fonction. Nous avons donné à `:my_loop` une nouvelle définition. Quand le thread `:looper` a rebouclé, il a simplement appelé la nouvelle définition.

Essayez de le modifier encore, changez la note, changer la durée de sommeil. Comment faire pour ajouter une instruction `use_synth` ? Par exemple, changez-le en :

    define :mon_son do
      use_synth :tb303
      play 50, release: 0.3
      sleep 0.25
    end

Maintenant, ça sonne plutôt intéressant, mais on peut le pimenter un peu plus. Au lieu de jouer la même note encore et encore, essayez de jouer un accord :

    define :mon_son do
      use_synth :tb303
      play chord(:e3, :minor), release: 0.3
      sleep 0.5
    end

Comment faire pour jouer des notes de l’accord aléatoirement :

    define :my_sound do
      use_synth :tb303
      play choose(chord(:e3, :minor)), release: 0.3
      sleep 0.25
    end

Ou utiliser une valeur de cutoff aléatoire :

    define :my_sound do
      use_synth :tb303
      play choose(chord( :e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
      sleep 0.25
    end

Finalement, ajoutons quelques notes de batterie :

    define :my_sound do
      use_synth :tb303
      sample :drum_bass_hard, rate: rrand(0.5, 2)
      play choose(chord( :e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
      sleep 0.25
    end

Maintenant, les choses commencent à devenir passionnantes !

Toutefois, avant que vous bondissiez et que vous vous lanciez dans le codage en direct avec des fonctions et des fils d’exécution, arrêtez ce que vous êtes en train de faire et lisez la section suivante sur `live_loop` qui va changer à jamais votre façon de coder dans Sonic Pi…

# 9.2 - Boucles en direct

Ok, ainsi cette section du tutoriel est la véritable perle. Si vous ne lisez qu’une section, ce devrait être celle-ci. Si vous avez lu la section précédente sur les fondamentaux du codage en direct, `live_loop` est une manière simple de faire exactement la même chose mais sans avoir tant à écrire.

Si vous n’avez pas lu la section précédente, `live_loop` est la meilleure façon d’improviser avec Sonic Pi.

Jouons. Écrivez le code suivant dans un tampon :

    live_loop :foo do
      play 60
      sleep 1
    end

Maintenant pressez le bouton Exécuter. Vous entendez un bip basique à chaque temps. Rien de plaisant pour l’instant. Toutefois, ne pressez pas tout de suite le bouton Arrêter. Changez le `60` en `65` et pressez Exécuter à nouveau.

Woah ! Ça a changé automatiquement sans manquer un temps. C’est du codage en direct.

Pourquoi ne pas le modifier pour ressembler plus à une basse ? Modifiez juste votre code pendant que ça joue :

    live_loop :foo do
      use_synth :prophet
      play :e1, release: 8
      sleep 8
    end

Puis pressez Exécuter.

Faisons bouger le cutoff aléatoirement :

    live_loop :foo do
      use_synth :prophet
      play :e1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end

Puis pressez Exécuter à nouveau.

Ajoutez de la batterie :

    live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :e1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end

Changez la note de `e1` en `c1` :

    live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :c1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end

Maintenant, arrêtez de me suivre et jouez vous-même ! Ayez du plaisir !

# 9.3 - Boucles multiples en direct

Considérez la boucle en direct suivante :

    live_loop :foo do
      play 50
      sleep 1
    end

Vous vous êtes peut-être demandé pourquoi elle avait besoin du nom `:foo`. Ce nom est important parce qu’il signifie que cette boucle est différente des autres boucles en direct.

Il ne peut y avoir deux boucles en direct en cours d’exécution avec le même nom.

Ce qui signifie que si nous voulons de multiples boucles en direct s’exécutant en simultané, nous devons simplement leur donner des noms différents :

    live_loop :foo do
      use_synth :prophet
      play :c1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end
    live_loop :bar do
      sample :bd_haus
      sleep 0.5
    end

Vous pouvez maintenant modifier et changer chaque boucle indépendamment et tout fonctionne.

## Synchronisation des boucles en direct

Une chose que vous pourriez avoir déjà remarqué est que ces boucles en direct fonctionnent automatiquement avec le mécanisme de thread que nous avons exploré précédemment. Chaque fois qu’une boucle en direct boucle, elle génère un nouvel événement `cue` avec le même nom que la boucle. Par conséquent, nous pouvons nous `sync` sur ces repères pour garantir que ces boucles soient synchronisées sans avoir à arrêter quoi que ce soit.

Considérez ce code mal synchronisé :

    live_loop :foo do
      play :e4, release: 0.5
      sleep 0.4
    end
    live_loop :bar do
      sample :bd_haus
      sleep 1
    end

Voyons si nous pouvons corriger le timing et synchroniser sans arrêter l’exécution. Corrigeons la boucle `:foo` pour l’aligner sur le facteur de sleep de 1 - quelque chose comme `0.5` fera l’affaire :

    live_loop :foo do
      play :e4, release: 0.5
      sleep 0.5
    end
    live_loop :bar do
      sample :bd_haus
      sleep 1
    end

Cependant, nous n’avons pas encore tout à fait fini - vous remarquerez que les temps ne battent pas ensemble correctement. C’est parce que les boucles sont déphasées. Corrigeons cela en les synchronisant :

    live_loop :foo do
      play :e4, release: 0.5
      sleep 0.5
    end
    live_loop :bar do
      sync :foo
      sample :bd_haus
      sleep 1
    end

Wow, tout est maintenant parfaitement en phase - tout cela sans arrêter.

Maintenant, allez de l’avant et codez en direct avec des boucles en direct !

# 9.4 - Avance automatique

Quelque chose que vous vous retrouverez probablement à faire beaucoup en codant en direct est de boucler au travers d’anneaux. Vous mettrez des notes dans des anneaux pour les mélodies, des pauses pour les rythmes, des progressions d’accords, des variations de timbre, etc. etc.

## Parcours automatique des anneaux

Sonic Pi fournit un outil très pratique pour travailler avec les anneaux à l’intérieur des `live_loop`s. Il s’agit du système d’avance automatique (“tick”). Dans la section sur les anneaux, on parlait d’un compteur qui augmente constamment, comme un nombre courant de battements. “Tick” implémente justement cette idée. Il vous fournit la capacité de parcourir des anneaux. Regardons un exemple :

    counter = 0
    live_loop :arp do
      play (scale :e3, :minor_pentatonic)[counter], release: 0.1
      counter += 1
      sleep 0.125
    end

C’est l’équivalent de :

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick, release: 0.1
      sleep 0.125
    end

Ici, nous prenons simplement la gamme mineure pentatonique de Mi3 et nous la parcourons élément par élément. C’est fait en ajoutant `.tick` à la fin de la déclaration de la gamme. Ce “tick” est local à la boucle en direct, ainsi chaque boucle en direct a son propre “tick” indépendant :

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick, release: 0.1
      sleep 0.125
    end
    live_loop :arp2 do
      use_synth :dsaw
      play (scale :e2, :minor_pentatonic, num_octaves: 3).tick, release: 0.25
      sleep 0.25
    end

## Fonction Tick

Vous pouvez également appeler `tick` comme une fonction standard et utiliser sa valeur de retour comme un index :

    live_loop :arp do
      idx = tick
      play (scale :e3, :minor_pentatonic)[idx], release: 0.1
      sleep 0.125
    end

Cependant, c’est plus joli d’appeler `.tick` à la fin. La fonction `.tick` est faite pour les cas où vous voulez faire des fantaisies avec la valeur retournée ou utiliser les “ticks” pour autre chose que l’indexation des anneaux.

## Fonction Look

La chose magique apportée par “tick” est que non seulement un nouvel index est retourné (ou la valeur de l’anneau à cet index), mais qu’il garantit que la fois suivante où vous l’appellerez, vous obtiendrez la valeur suivante. Jetez un œil aux exemples dans la documentation pour `.tick` pour voir les différentes façons de l’employer. Toutefois, pour le moment, il est important de souligner que quelquefois, vous voulez juste obtenir la valeur courante de “tick” sans l’incrémenter. Ceci est disponible via la fonction `look`. Vous pouvez appeler `look` comme une fonction standard ou ajouter `.look` à la fin d’un anneau.

## Nommage des Ticks

Finalement, vous avez quelques fois besoin de plus d’un “tick” par boucle en direct. C’est réalisé en donnant un nom à vos “ticks” :

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick(:foo), release: 0.1
      sleep (ring 0.125, 0.25).tick(:bar)
    end

Ici, nous utilisons deux “ticks”, un pour la note à jouer et un autre pour la durée de sommeil. Comme ils sont tous deux dans la même boucle, pour les maintenir indépendants, nous devons leur donner des noms uniques. C’est exactement le même genre de solution que dans le cas du nommage des `live_loop`s - nous passons simplement un symbole précédé d’un `:`. Dans l’exemple ci-dessus, nous avons appelé un “tick” `:foo` et l’autre `:bar`. Si nous voulons juste connaître leur valeur, nous devons aussi passer le nom du “tick” à `look`.

## Ne faites pas de choses trop compliquées

La plupart de la puissance du système des “ticks” n’est pas utile quand vous débutez. N’essayez pas et n’apprenez pas tout dans cette section. Concentrez-vous seulement sur le parcours d’un simple anneau. Cela vous procurera la plus grande part de la joie et de la simplicité du parcours des anneaux dans vos `live_loop`s.

Jetez un œil à la documentation des `tick`s où se trouvent de nombreux exemples utiles, et joyeux parcours automatiques !

# 10 - État du temps

Il est souvent utile d’avoir de l’information qui est partagée à travers plusieurs fils d’exécution ou boucles en direct. Par exemple, vous pourriez vouloir partager une notion de la clef courante, de BPM, ou des concepts encore plus abstraits comme la ‘complexité’ courante (que vous pourriez potentiellement interpréter de manière différente à travers divers fils). Nous ne voulons pas non plus perdre aucune nos garanties existantes de déterminisme en faisant cela. En d’autres mots, nous aimerions être toujours capable de partager du code avec d’autres, et savoir exactement ce qu’ils vont entendre en l’exécutant. À la fin de la Section 5.6 de ce tutoriel, nous avons discuté brièvement de pourquoi nous ne devrions pas utiliser des variables pour partager l’information à travers les fils d’exécution à cause d’une perte de déterminisme (ce qui est dû à la concurrence).

La solution de Sonic Pi au problème de travailler facilement avec les variables globales d’une manière déterministe est un système novateur appelé l’État du Temps. Cela peut sembler complexe et difficile (en fait, au Royaume-Uni, la programmation avec plusieurs fils d’exécution et de la mémoire partagée est habituellement un sujet de niveau universitaire). Toutefois, comme vous allez le voir, tout comme jouer votre première note, Sonic Pi rend incroyablement simple le partage d’état entre les fils d’exécution tout en conservant vos programmes avec des fils d’exécution sûrs et déterministes..

Rencontrez `get` et `set`…

# 10.1 - Paramétrer et obtenir

Sonic Pi a un magasin de mémoire global appelé État du Temps. Les deux choses principales que vous faites avec sont de `set` de l’information et de `get` de l’information. Explorons plus en détails…

## Paramétrer

Pour stocker de l’information dans l’État du Temps, nous avons besoin de deux choses :

1. l’information que nous voulons stocker,
2. un nom unique (clé) pour l’information.

Par exemple, nous voulons stocker le chiffre `3000` avec la clé `:intensity`. C’est possible en utilisant la fonction `set` :

    set :intensity, 3000

Nous pouvons utiliser n’importe quel nom pour notre clé. Si de l’information a déjà été stockée avec cette clé, notre nouveau `set` va l’écraser :

    set :intensity, 1000
    set :intensity, 3000

Dans l’exemple ci-dessus, étant donné que nous stockons deux nombres avec la même clé, le dernier appel à `set` “gagne”, alors le nombre associé à `:intensity` sera `3000` étant donné que le premier appel à `set` est écrasé.

## Obtenir

Pour obtenir de l’information de l’État du Temps, nous avons seulement besoin de la clé que nous avons utilisée pour la `set`, qui est dans notre cas `:intensity`. Nous avons alors seulement besoin d’appeler `get[:intensity]` que nous pouvons voir en affichant le résultat dans le journal :

    print get[:intensity] #=> prints 3000

Notez que l’appel à `get` peut retourner de l’information qui a été `set` dans une exécution précédente. Une fois qu’une pièce d’information a été `set`, elle est disponible jusqu’à ce qu’elle soit écrasée (comme nous l’avons fait avec la valeur de `:intensity` passant de `1000` à `3000` ci-dessus) ou que Sonic Pi soit fermé.

## Fils multiples

L’avantage principal du système d’État du Temps est qu’il peut être utilisé de façon sûre au travers des fils d’exécution ou des boucles en direct. Par exemple, vous pourriez avoir une boucle en direct qui affecte de l’information et une autre qui l’obtient :

    live_loop :setter do
      set :foo, rrand(70, 130)
      sleep 1
    end
    live_loop :getter do
      puts get[:foo]
      sleep 0.5
    end

La chose plaisante avec l’utilisation de `get` et `set` au travers des fils d’exécution de cette façon est que ça produira toujours le même résultat à chaque fois que vous l’exécuterez. Allez-y, essayez-le. Regardez si vous obtenez le journal suivant :

    {run: 0, time: 0.0}
     └─ 125.72265625
    {run: 0, time: 0.5}
     └─ 125.72265625
    {run: 0, time: 1.0}
     └─ 76.26220703125
    {run: 0, time: 1.5}
     └─ 76.26220703125
    {run: 0, time: 2.0}
     └─ 114.93408203125
    {run: 0, time: 2.5}
     └─ 114.93408203125
    {run: 0, time: 3.0}
     └─ 75.6048583984375
    {run: 0, time: 3.5}
     └─ 75.6048583984375

Essayez de l’exécuter quelques fois - vous voyez, c’est toujours la même chose. C’est ce qu’on appelle un comportement déterministe et c’est très important quand nous voulons partager notre musique sous forme de code et que nous savons que la personne qui exécute le code entend exactement ce que nous voulions qu’elle entende (tout comme jouer un MP3 ou flux d’internet sonne de la même façon pour tout ceux qui écoutent).

## Un système d’état simple et déterministe

À la Section 5.6, nous avons discuté de pourquoi l’utilisation des variables à travers les fils peut entraîner des comportements hasardeux. Ceci nous empêche de pouvoir, de façon sûre, reproduire du code comme ceci :

    ## Un exemple de comportement non-déterministe
    ## (du à la concurrence causée pas de multiple
    ## boucles en direct qui manipule la même variable
    ## au même moment).
    ##
    ## Si vous exécutez ce code, vous remarquerez
    ## que la liste qui est imprimée
    ## n'est pas toujours triée!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

Regardons à quoi cela peut ressembler en utilisant `get` and `set` :

    ## Un exemple de comportement déterministe
    ## (malgré l'accès avec concurrence de l'état partagé)
    ## en utilisant le nouveau système d'État du Temps de Sonic Pi.
    ##
    ## Quand ce code est exécuté, la liste qui est
    ## imprimée est toujours triée!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end

Remarquez comment le code est pratiquement identique à la version qui utilisait la variable auparavant. Cependant, quand vous exécutez votre code, il agit de la façon que vous vous attendez comme avec n’importe lequel code de Sonic Pi typique - il fait la même chose chaque fois dans ce cas grâce au système d’État du Temps.

Donc, lorsque vous partagez de l’information au travers de boucles en direct et de fils d’exécution, utilisez `get` et `set` au lieu de variables pour un comportement déterministe et reproductible.

# 10.2 - Sync

La section 5.7 a introduit les fonctions `cue` et `sync` lorsque nous rencontrons des problèmes de synchronisation de fils d’exécution. Ce qui n’y était pas expliqué était qu’il s’agit du système d’État du Temps qui permet cette fonctionnalité. Enfaite, la fonction `set` est une variation de `cue` et est construite sur la même fonctionnalité de base qui est d’insérer de l’information dans le système d’État du Temps. De plus, `sync` a été créé d’une façon qui lui permet de travailler parfaitement avec l’État du Temps - toute information que nous prévoyons stocker dans l’État du Temps, nous pouvons la synchroniser.

## Attendre pour les événements

Regardons rapidement comment utiliser `sync` pour attendre que de nouveaux événements soient ajoutés à l’État du Temps :

    in_thread do
      sync :foo
      sample :ambi_lunar_land
    end
    sleep 2
    set :foo, 1

Dans cet exemple, nous commençons par créer un fil d’exécution qui attend pour qu’un événement `:foo` soit ajouté à l’État du Temps. Après la déclaration du fil d’exécution, nous dormons pour deux rythmes et nous `set` `:foo` à `1`. Cela relâche ensuite le `sync` qui se rend ensuite à la prochaine ligne qui est de déclencher l’exemple `:ambi_lunar_land`.

Noter que `sync` attend toujours pour des événements futurs et qu’il bloque le fil d’exécution actuel en attendant ce nouvel événement. Également, il va hériter du temps logique du fil d’exécution qui est déclenché par `set` ou `cue`, donc il peut être utilisé également pour synchroniser le temps.

## Transférer des valeurs dans le Futur

Dans l’exemple ci-dessus, nous avons affecté `1` à `:foo` et en avons rien fait. Nous pouvons obtenir cette valeur à partir du fil d’exécution en appelant `sync` :

    in_thread do
      amp = sync :foo
      sample :ambi_lunar_land, amp: amp
    end
    sleep 2
    set :foo, 0.5

Notez que les valeurs transférées au travers de `set` et `cue` doivent être protégées des fils d’exécution - c’est-à-dire des anneaux immuables, des nombres, des symboles ou des chaînes de caractères fixes. Sonic Pi lancera une erreur si la valeur que vous essayez de stocker dans l’État du Temps n’est pas valide.

# 10.3 - Correspondance de motif

Quand vous obtenez et affectez de l’information dans l’État du Temps, il est possible d’utiliser des clés plus complexes que les symboles basiques comme `:foo`et `:bar`. Vous pouvez également utiliser des chaînes de caractères de format URL appelées chemin comme `"/foo/bar/baz"`. Lorsque nous avons commencé à travailler avec les chemins, nous pouvons commencer à prendre avantage du système sophistiqué de correspondance de motif de Sonic Pi pour `get` et `sync` des chemins “similaires” au lieu “d’identiques”. Étudions cela de plus près.

## Faire correspondre n’importe quel segment de chemin

Assumons que nous voulons attendre pour le prochain événement qui a trois segments de chemin :

    sync "/*/*/*"

Ceci va faire une correspondance avec tout événement d’État du Temps avec exactement trois segments de chemin, et ce, peu importe leur nom. Par exemple :

- `cue "/foo/bar/baz"`
- `cue "/foo/baz/quux"`
- `cue "/eggs/beans/toast"`
- `cue "/moog/synths/rule"`

Toutefois, ça ne correspondra pas avec des chemins qui ont plus ou moins de segments. L’élément suivant n’aura pas de correspondance :

- `cue "/foo/bar"`
- `cue "/foo/baz/quux/quaax"`
- `cue "/eggs"`

Chaque `*` signifie n’importe quel contenu. Donc, nous pourrions trouver des correspondance avec des chemins d’un seul segment avec `/*` ou des chemins avec cinq segments avec `/*/*/*/*/*`

## Faire des correspondances de segments partiels

Si nous savons par quoi le segment va commencer ou finir, nous pouvons utiliser un `*` en plus d’un nom de segment partiel. Par exemple : `"/foo/b*/baz"` correspondra à tout chemin possédant trois segments, le premier étant `foo`, le dernier `baz`, et celui du milieu pouvant être n’importe quoi commençant par un `b`. Il correspondra alors à :

- `cue "/foo/bar/baz"`
- `cue "/foo/baz/baz"`
- `cue "/foo/beans/baz"`

Cependant, cela ne correspondrait pas avec ceci :

- `cue "/foo/flibble/baz"`
- `cue "/foo/abaz/baz"`
- `cue "/foo/beans/baz/eggs"`

Vous pouvez également placer le `*` au début du segment pour spécifier les derniers caractères d’un segment : `"/foo/*zz/baz"` ce qui correspondra à n’importe quel triple segment `cue` ou `set` où le premier segment est `foo`, le dernier est `baz` et celui du milieu fini avec `zz` comme `"cue "/foo/whizz/baz"`.

## Faire correspondre des segments de chemins imbriqués

Parfois, vous ne connaissez pas le nombre de segments de chemin devant correspondre. Dans ce cas, vous pouvez utiliser la puissante double-étoile : `**` et ainsi `"/foo/**/baz"` correspondra à :

- `cue "/foo/bar/baz"`
- `cue "/foo/bar/beans/baz"`
- `cue "/foo/baz"`
- `cue "/foo/a/b/c/d/e/f/baz"`

## Faire correspondre des lettres

Vous pouvez utiliser le caractère `?` pour faire une correspondance sur un seul caractère comme `"/?oo/bar/baz"` ce qui correspondra avec :

- `cue "/foo/bar/baz"`
- `cue "/goo/bar/baz"`
- `cue "/too/bar/baz"`
- `cue "/woo/bar/baz"`

## Faire correspondre plusieurs mots

Si vous savez qu’un segment pourrait être un parmi un ensemble particulier de mots, vous pouvez utiliser les correspondances `{` et `}` pour spécifier une liste de choix tel que `"/foo/{bar,beans,eggs}/quux"` qui correspondra uniquement à ceci :

- `cue "/foo/bar/quux"`
- `cue "/foo/beans/quux"`
- `cue "/foo/eggs/quux"`

## Faire correspondre plusieurs lettres

Finalement, vous pouvez faire correspondre à une sélection de lettres si vous utilisez les correspondances `[` et `]` pour spécifier une liste de choix tel que `"/foo/[abc]ux/baz"` qui correspondra uniquement à :

- `cue "/foo/aux/baz"`
- `cue "/foo/bux/baz"`
- `cue "/foo/cux/baz"`

Vous pouvez également utiliser le caractère `-` pour spécifier un ensemble de lettres. Par exemple `"/foo/[a-e]ux/baz"` qui correspondra uniquement à :

- `cue "/foo/aux/baz"`
- `cue "/foo/bux/baz"`
- `cue "/foo/cux/baz"`
- `cue "/foo/dux/baz"`
- `cue "/foo/eux/baz"`

## Combiner des correspondances

En appelant `sync` ou `get`, vous êtes libre de combiner des correspondances dans n’importe quel ordre qui vous convient pour faire correspondre des événements d’état du Temps créés par `cue` ou `set`. Regardons un exemple fou :

    in_thread do
      sync "/?oo/[a-z]*/**/ba*/{quux,quaax}/"
      sample :loop_amen
    end
    sleep 1
    cue "/foo/beans/a/b/c/d/e/bark/quux/"

## Correspondance de motif OSC

Pour les curieux, ces règles de correspondance sont basées sur la spécification de correspondance de motif Open Sound Control, qui est expliquée en détail ici : https://opensoundcontrol.stanford.edu/spec-1_0.html

# 11 - MIDI

Une fois que vous avez maîtrise la conversion du code en musique, vous vous demandez peut-être : quel est la suite ? Parfois les contraintes de travailler purement dans la syntaxe de Sonic Pi et d’un système de son peut paraître excitant et vous placez dans une nouvelle position créative. Toutefois, parfois il est essentiel de sortir du code pour aller dans le vrai monde. Nous voulons deux choses supplémentaires :

1. Pour être capable de convertir des actions du vrai monde en événements de Sonic Pi avec lesquels coder
2. Pour être capable d’utiliser le model fort de timing de Sonic Pi et ses sémantiques pour contrôler et manipuler les objets dans le vrai monde

Heureusement, il existe un protocole depuis les années 80 qui permet exactement ce genre d’interactions : MIDI. Il y a un nombre incroyable de périphériques externes en incluant les claviers, les contrôleurs, les séquenceurs et des logiciels d’audio professionnels qui supportent tous le MIDI. Nous pouvons utiliser le MIDI pour recevoir des données et en envoyer.

Sonic Pi supporte entièrement le protocole MIDI ce qui vous permet de connecter votre code au vrai monde. Explorons-le plus en détails …

# 11.1 - 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 !

# 11.2 - Sortie MIDI

En plus de recevoir des événements MIDI, nous pouvons également envoyer des événements MIDI pour déclencher et contrôler des équipements externes comme les synthés, claviers et autres périphériques. Sonic Pi propose un ensemble complet de fonctions pour envoyer des messages MIDI variés comme :

1. Note activée - `midi_note_on`
2. Note désactivée - `midi_note_off`
3. Contrôler le changement - `midi_cc`
4. Amplitude courbée - `midi_pitch_bend`
5. Tic d’horloge - `midi_clock_tick`

Il y a plein d’autres messages MIDI supportés également - jetez un coup d’œil à la documentation de l’API pour toutes les autres fonctions qui débutent par `midi_`.

## Se connecter à un périphérique MIDI

Dans le but d’envoyer un message MIDI à un périphérique externe, nous devons commencer par le connecter. Regardez la sous-section ‘Se connecter à un contrôleur MIDI’ dans la section 11.1 pour plus de détails. Notez que si vous utilisez l’USB, connecter un périphérique à lequel vous envoyez (au lieu de recevoir) est la même procédure. Cependant, si vous utilisez les connecteurs DIN classiques, assurez-vous de connecter le port de sortie MIDI à votre ordinateur. Vous devriez voir votre périphérique MIDI listé dans le panneau des préférences.

## Envoyer des événements MIDI

Les nombreuses fonctions `midi_*` fonctionnent comme `play`, `sample` et `synth` puisqu’elles envoient un message au temps (logique) actuel. Par exemple, pour étaler des appels aux fonctions `midi_*`, vous devez utiliser `sleep` tout comme vous l’avez fait avec `play`. Jetons un coup d’oeil :

    midi_note_on :e3, 50

Cela va envoyer une note MIDI sur l’événement au périphérique MIDI connecté avec une vélocité de 50. ( Notez que Sonic Pi va convertir automatiquement les notes dans le format `:e3` à leur nombre MIDI correspondant comme 52 dans ce cas-ci.)

Si votre périphérique MIDI connecté est un synthétiseur, vous devriez être capable de l’entendre jouer une note. Pour le désactiver, utiliser `midi_note_off` :

    midi_note_off :e3

## Sélectionner un périphérique MIDI

Par défaut, Sonic Pi va envoyer chaque message MIDI à tout les périphériques connectés sur tous les canaux MIDI. Cela est fait dans le but de rendre facile le travail avec un périphérique connecté sans avoir à configurer quoi que ce soit. Cependant, parfois un périphérique MIDI va traiter les canaux MIDI d’une manière particulière ( peut-être que chaque note a un canal séparé) et vous pourriez également vouloir connecter plus d’un périphérique MIDI en même temps. Dans des configurations plus compliquées, vous pouvez vouloir être plus sélectif sur quel périphérique MIDI reçoit quel(s) message(s) et sur quel canal.

On peut spécifier à quel périphérique on veut envoyer en utilisant l’option `port:`, en utilisant le nom du périphérique comme affiché dans les préférences :

    midi_note_on :e3, port: "moog_minitaur"

On peut également spécifier quel canal on veut envoyer en utilisant l’option `channel:` (en utilisant une valeur dans l’intervalle de 1 à 16) :

    midi_note_on :e3, channel: 3

Évidemment, nous pouvons aussi spécifier les deux en même temps pour envoyer à un périphérique spécifique sur un canal spécifique :

    midi_note_on :e3, port: "moog_minitaur", channel: 5

## Studio MIDI

Finalement, une chose très amusante à faire est de connecter la sortie audio de votre synthétiseur MIDI à l’une des entrées audio de votre carte de son. Vous pouvez alors contrôler votre synthé avec du code en utilisant les fonctions `midi_*` et également manipuler l’audio en utilisant `live_audio` et FX :

    with_fx :reverb, room: 1 do
      live_audio :moog
    end
    live_loop :moog_trigger do
      use_real_time
      midi (octs :e1, 3).tick, sustain : 0.1
      sleep 0.125
    end

(La fonction `midi` est disponible en tant que raccourci pratique pour envoyer les événements de notes ouvertes et fermées avec une simple commande. Regarder sa documentation pour davantage d’informations).

# 12 - OSC

En plus du MIDI, une autre façon d’obtenir de l’information entrante et sortante de Sonic Pi est via un réseau en utilisant un protocole simple appelé OSC - Open Sound Control. Cela va vous laisser envoyer et recevoir des messages de programmes externes ( s’exécutant sur votre ordinateur et sur des ordinateurs externes) ce qui augmente le potentiel de contrôle bien plus haut que le MIDI qui a des limitations dues à son design des années 80.

Par exemple, vous pourriez écrire un programme dans un autre langage de programmation qui envoie et reçoit OSC (il existe des librairies OSC pour presque tous les langages communs) et travailler directement avec Sonic Pi. Les possibilités d’utilisation de cela sont seulement limitées par votre imagination.

# 12.1 - Réception OSC

Par défaut, lorsque Sonic Pi est lancé, il écoute sur le port 4560 pour des messages OSC entrant de programmes sur le même ordinateur. Cela veut dire que sans aucune configuration, vous pouvez envoyer à Sonic Pi un message OSC et il sera affiché dans la queue du journal tout comme les messages MIDI entrants. Cela veut également dire que tout message OSC entrant est aussi automatiquement ajouté à l’État du Temps, ce qui veut dire que vous pouvez aussi utiliser `get` et `sync` pour travailler avec l’information entrante, comme avec le MIDI, et synchroniser `live_loops` - voir les sections 5.7 et 10.2 pour récapituler comment cela fonctionne.

## Un écouteur OSC basique

Construisons un écouteur OSC basique :

    live_loop :foo do
      use_real_time
      a, b, c = sync "/osc*/trigger/prophet"
      synth :prophet, note: a, cutoff: b, sustain: c
    end

Dans cet exemple, nous décrivons un chemin OSC `"/osc*/trigger/prophet"` sur lequel nous nous synchronisons. Cela peut être n’importe quel chemin OSC valide (toutes les lettres et chiffres sont supportés et le `/` est utilisé comme dans une URL pour diviser le chemin en plusieurs mots). Le préfixe `/osc` est ajouté par Sonic Pi à tous les messages OSC entrants, alors nous devons envoyer un message OSC avec le chemin `/trigger/prophet` pour que notre `sync` cesse de bloquer et que le synthé prophet soit déclenché.

## Envoyer du OSC à Sonic Pi

Nous pouvons envoyer du OSC à Sonic Pi à partir de n’importe lequel langage de programmation qui a une librairie OSC. Par exemple, si nous envoyons du OSC à partir de Python, nous allons faire quelque chose ressemblant à ceci :

    from pythonosc import osc_message_builder
    from pythonosc import udp_client
    sender = udp_client.SimpleUDPClient('127.0.0.1', 4560)
    sender.send_message('/trigger/prophet', [70, 100, 8])

Ou si nous envoyons du OSC à partir de Clojure, nous allons faire quelque chose qui ressemble à ceci à partir de la REPL :

    (use 'overtone.core)
    (def c (osc-client "127.0.0.1" 4560))
    (osc-send c "/trigger/prophet" 70 100 8)

## Recevoir des machines externes

Pour des raisons de sécurité, par défaut Sonic Pi ne laisse pas les machines distantes lui envoyer des messages OSC. Cependant, vous pouvez activer le support des machines distantes dans Préférences->IO->Réseau->Recevoir des messages OSC distants. Une fois que vous l’avez activé, vous pouvez recevoir les messages OSC de n’importe quel ordinateur sur votre réseau. Habituellement, la machine expéditrice a besoin de connaître votre adresse IP (un identificateur unique de ton ordinateur sur ton réseau – comme un numéro de téléphone ou une adresse courriel). Vous pouvez découvrir l’adresse IP de votre ordinateur en regardant la section IO de votre panneau de préférences. (Si votre machine a plus d’une adresse IP, placer votre souris sur l’adresse listée fera apparaître une liste de toutes les adresses connues).

Prenez note, des programmes comme TouchOSC pour iPhone et Android supportent l’envoi de OSC comme fonctionnalité standard. Alors, une fois que vous écoutez les machines distantes et que vous connaissez votre adresse IP, vous pouvez commencer instantanément l’envoi de messages à partir d’applications comme TouchOSC ce qui vous permet de construire vos propres contrôles tactiles personnalisés avec glisseurs, boutons, cadrans, etc. Cela vous fournit un grand éventail de possibilités d’entrée.

# 12.2 - Envoyer du OSC

En plus de recevoir du OSC et de travailler avec en utilisant l’État du Temps, nous pouvons également envoyer des messages OSC en synchronisation avec notre musique (tout comme nous pouvons envoyer des messages MIDI en synchronisation avec notre musique). Nous devons seulement savoir à quelle adresse IP et port nous envoyons. Essayons-le :

    use_osc "localhost", 4560
    osc "/hello/world"

Si vous exécutez le code ci-dessus, vous allez remarquer que Sonic Pi s’envoie lui-même un message OSC ! Ceci parce que nous avons configuré l’adresse IP et le port de la machine courante au port par défaut pour OSC. C’est essentiellement la même chose que de se poster une lettre à soi-même - le paquet OSC est créé, quitte Sonic Pi, se rend à la pile réseau du système d’exploitation qui va retourner le paquet à Sonic Pi et est reçu ensuite comme un message OSC standard qui est visible dans la queue du journal en tant que message entrant `"/osc:127.0.0.1:4560/hello/world`. (Remarquez comment Sonic Pi préfixe automatiquement tous les messages OSC entrants avec `/osc` puis le nom d’hôte et le port de l’expéditeur.)

## Envoyer du OSC à d’autres programmes

Évidemment, envoyer des messages OSC à nous-mêmes peut être amusant, mais pas très utile. Le vrai bénéfice commence quand nous envoyons des messages à d’autres programmes :

    use_osc "localhost", 123456
    osc "/hello/world"

Dans ce cas, nous assumons qu’il existe un autre programme sur la même machine qui écoute sur le port 123456. Si c’est le cas, il va recevoir un message OSC `"/hello/world` avec lequel il peut faire ce qu’il veut.

Si votre programme s’exécute sur une autre machine, nous avons besoin de savoir son adresse IP que nous allons utiliser au lieu de `"localhost"` :

    use_osc "192.168.10.23", 123456
    osc "/hello/world"

Maintenant, nous pouvons envoyer des messages OSC à n’importe quel périphérique accessible via nos réseaux locaux et même l’internet !

# 13 - Audio multi-canaux

Jusqu’à maintenant, en terme de production de son, nous avons exploré le déclenchement des synthés et des sons enregistrés avec les fonctions `play`, `synth` et `sample`. Celles-ci ont généré de l’audio qui a été joué au travers de notre système de son stéréo. Cependant, plusieurs ordinateurs offrent également la possibilité de recevoir du son, par exemple avec un microphone, en plus d’avoir la possibilité d’envoyer le son à plus de deux haut-parleurs. Souvent, cette possibilité existe par l’utilisation d’une carte de son externe - celles-ci sont disponibles pour toutes les plateformes. Dans cette section du tutoriel, nous allons regarder comment nous pouvons prendre avantage de ces cartes de sons externes et travailler sans effort avec de multiples canaux d’audio entrants et sortants de Sonic Pi.

# 13.1 - Son entrant

Une façon simple (et peut-être familière) d’accéder les sons entrants est en utilisant notre ami `synth` en spécifiant le synthé `:sound_in` :

    synth :sound_in

Cela va fonctionner comme n’importe quel synthé comme par exemple `synth :dsaw` à l’exception que l’audio généré sera lu directement de la première entrée de votre carte de son système. Sur les portables, c’est typiquement le microphone intégré, mais si vous avez une carte de son externe, vous pouvez brancher n’importe quel audio entrant dans la première entrée.

## Augmenter la durée

Une chose que vous pourriez remarquer est que tout comme `synth :dsaw`, le synthé `:sound_in` dure seulement pour 1 rythme puisqu’il a une enveloppe standard. Si vous voulez le garder ouvert pour un peu plus longtemps, changez les paramètres d’enveloppe ADSR. L’exemple suivant va conserver le synthé ouvert pour 8 rythmes avant de fermer la connexion :

    synth :sound_in, sustain: 8

## Ajout d’effets (FX)

Bien sûr, tout comme n’importe quel synthé normal, vous pouvez facilement ajouter des couches d’effets avec le bloc FX :

    with_fx :reverb do
      with_fx :distortion do
        synth :sound_in, sustain: 8
      end
    end

Si vous avez connecté une guitare dans votre première entrée, vous devriez être capable de l’entendre avec de la distorsion et de la réverbération jusqu’à ce que le synthé se termine comme prévu.

Vous êtes libre d’utiliser le synthé `:sound_in` aussi souvent que vous le voulez de façon concurrente (tout comme vous le faites avec n’importe lequel synthé normal). L’exemple suivant va jouer deux synthés `:sound_in` en même temps - l’un via la distorsion et l’autre via la réverbération :

    with_fx :distortion do
      synth :sound_in, sustain: 8
    end
    with_fx :reverb do
      synth :sound_in, sustain: 8
    end

## Entrées multiples

Vous pouvez sélectionner quelle entrée audio vous voulez jouer avec l’option `input:`. Vous pouvez également spécifier une entrée stéréo (deux entrées consécutives) en utilisant le synthé `:sound_in_stereo`. Par exemple, si vous avez une carte de son avec au moins trois entrées, vous pouvez traiter les deux premières en tant que flux stéréo et y ajouter de la distorsion et la troisième en tant que flux mono et y ajouter une réverbération avec le code suivant :

    with_fx :distortion do
      synth :sound_in_stereo, sustain: 8, input: 1
    end
    with_fx :reverb do
      synth :sound_in, sustain: 8, input: 3
    end

## Problèmes potentiels

Cependant, même s’il s’agit d’une technique utile, il y a quelques limitations à cette approche. Premièrement, cela fonctionne seulement pour une durée déterminée (étant donné qu’il a une enveloppe ASDR) et deuxièmement, il n’existe pas de façon de changer le FX une fois que le synthé a été déclenché. Ces deux choses sont des requêtes typiques lorsqu’on travaille avec des flux audio externes comme les microphones, les guitares et les synthétiseurs externes. Par conséquent, nous allons regarder la solution de Sonic Pi au problème de manipuler une (potentielle) infinité de flux d’entrée audio en direct : `live_audio`.

# 13.2 - Audio en direct

Le synthé `:sound_in`, comme décrit dans la section précédente, fournit une méthode très flexible et familière pour travailler avec les entrées audio. Toutefois, comme nous en avons discuté, elle a quelques problématiques lorsque nous travaillons avec une seule entrée audio comme un seul instrument (comme la voix ou une guitare). La meilleure approche pour travailler avec un seul flux d’audio en continu, et de loin, est d’utiliser `live_audio`.

## Une entrée audio nommée

`live_audio` partage quelques contraintes de design interne avec `live_loop` (d’où le nom similaire). Premièrement, il doit avoir un nom unique et deuxièmement, un seul flux `live_audio` avec ce nom peut exister à tout moment. Jetons un coup d’œil :

    live_audio :foo

Ce code va réagir d’une façon similaire à `synth :sound_in` avec quelques différences clés : il tourne pour toujours (jusqu’à ce que vous le stoppiez explicitement) et vous pouvez le bouger vers de nouveaux contextes FX dynamiquement.

## Travailler avec des FX

A son déclenchement initial, `live_audio` fonctionne exactement de la façon que vous pensez qu’il fonctionne avec FX. Par exemple, pour démarrer un flux audio en direct avec des réverbérations ajoutées, utiliser simplement un bloc FX `:reverb` :

    with_fx :reverb do
      live_audio :foo
    end

Toutefois, considérant que ce `live_audio` tourne pour toujours (au moins jusqu’à ce que vous l’arrêtiez), ce serait assez contraignant si, comme les synthés typiques, l’audio en direct était lié à l’intérieur du FX `:reverb` pour son existence entière. Heureusement, ce n’est pas le cas et cela a été conçu pour être facile à déplacer entre des FX différents. Essayons-le. Exécutez le code ci-dessus pour entendre l’audio en direct venir directement de la première entrée de votre carte de son. À noter, si vous utilisez un portable, cela correspondra habituellement à votre microphone intégré, alors il est recommandé d’utiliser des écouteurs pour arrêter le retour d’informations.

Maintenant, pendant que vous entendez l’audio live depuis votre carte son avec de la réverbération, modifiez le code ainsi :

    with_fx :echo do
      live_audio :foo
    end

Maintenant, pressez Exécuter, et vous entendrez immédiatement l’audio joué au travers de l’écho FX et plus via la réverbération. Si vous voulez les deux, modifiez le code à nouveau et pressez Exécuter :

    with_fx :reverb do
      with_fx :echo do
        live_audio :foo
      end
    end

Il est important de préciser que vous pouvez appeler `live_audio :foo` depuis tout thread ou tout boucle live, et il déplacera le synthé audio live de ce contexte actuel de thread. Vous pouvez donc facilement avoir plusieurs boucles live qui appellent `live_audio :foo` à différent moments faisant en sorte que le contexte d’effet soit automatiquement changé, ceci donnant des résultats intéressants.

## Arrêter l’audio en direct

Contrairement aux synthés standards, étant donné que `live_audio` n’a pas d’enveloppe, il va continuer de s’exécuter pour toujours (même si vous supprimez le code, une fonction demeure définie en mémoire même si vous supprimez le code dans l’éditeur). Pour l’arrêter, vous devez utiliser l’argument `:stop` :

    live_audio :foo, :stop

Cela peut être facilement redémarré en l’appelant sans l’argument `:stop` de nouveau :

    live_audio :foo

De plus, tous les synthés d’audio en direct qui s’exécutent sont arrêtés quand vous pressez sur le bouton Stop global (de même que pour tous les autres synthés et FX qui s’exécutent).

## Entrée stéréo

Pour ce qui est des canaux audio, par défaut `live_audio` agit similairement au synthé `:sound_in` dans le fait qu’il prend un simple flux d’entrée mono d’audio et le convertit en flux stéréo en utilisant le panoramique spécifié. Cependant, tout comme `:sound_in_stereo`, il est également possible de dire à `live_audio` de lire deux entrées audio consécutivement et de les traiter en tant que canaux de droite et de gauche directement. Cela est possible via l’option `:stereo`. Par exemple, pour traiter l’entrée 2 en tant que signal de gauche et l’entrée 3 en tant que signal de droite, vous avez besoin de configurer l’option `input:` à 2 et d’activer le mode stéréo comme suit :

    live_audio :foo, stereo: true, input: 2

Notez qu’une fois que vous avez démarré un flux d’audio en direct en mode stéréo, vous ne pouvez pas le changer en mono sans l’arrêter et le démarrer. Similairement, si vous le démarrez dans le mode mono par défaut, vous ne pouvez pas changer en stéréo sans arrêter et démarrer le flux.

# 13.3 - Son sortant

Jusqu’à maintenant dans cette section nous avons regardé comment avoir plusieurs flux d’audio dans Sonic Pi - soit par l’utilisation du synthé `:sound_in` ou par le système puissant `live_audio`. En plus de pouvoir travailler avec de multiples flux d’entrée audio, Sonic Pi peut également faire sortir plusieurs flux d’audio. Cela est possible via le FX `:sound_out`.

## Contextes de sortie

Récapitulons rapidement comment les synthés et les FX de Sonic Pi sortent leur audio à leur contexte FX courant. Par exemple, considérant ceci :

    with_fx :reverb do    # C
      with_fx :echo do    # B
        sample :bd_haus   # A
      end
    end

La façon la plus simple de comprendre ce qui se passe avec le flux audio est de commencer au niveau le plus interne du contexte audio et de remonter. Dans ce cas, le contexte le plus interne est étiqueté `A` et il s’agit de l’échantillon `:bd_haus` qui est déclenché. L’audio pour cela va directement dans son contexte qui est `B` - l’effet `:echo`. Cela ajoute de l’écho à l’audio entrant et l’émet en sortie à son contexte qui est `C` - l’effet `:reverb`. Cela ajoute ensuite de la réverbération à l’audio entrant et l’émet en sortie à son contexte qui est le niveau le plus haut - les haut-parleurs de gauche et droite (sortie 1 et 2 de votre carte audio). L’audio sort avec un signal stéréo via ces derniers.

## Effet de son sortant

Le comportement ci-dessus est vrai pour tous les synthés (incluant `live_audio`) et la majorité des FX, à l’exception de `:sound_out`. L’effet `:sound_out` accomplit deux choses. Premièrement, il émet en sortie son audio au contexte externe comme décrit ci-dessus. Deuxièmement, il émet aussi en sortie son audio directement à une sortie sur votre carte son. Jetons un coup d’œil :

    with_fx :reverb do      # C
      with_fx :sound_out, output: 3 do # B
        sample :bd_haus     # A
      end
    end

Dans cet exemple, notre échantillon `:bd_haus` sort son audio à son contexte externe qui est l’effet `:sound_out`. À son tour, il sort son audio à son contexte externe qui est l’effet `:reverb` (comme attendu). Cependant, il sort aussi un mélange mono à la troisième sortie de la carte de son système. L’audio généré dans `:sound_out` a donc deux destinations - l’effet `:reverb` et la sortie 3 de la carte audio.

## Sortie mono et stéréo

Comme nous l’avons vu, par défaut, l’effet `:sound_out` ressort un mix mono d’une entrée stéréo vers un canal spécifique en addition de passer le flux stéréo vers le contexte de sortie (comme prévu). Si le fait de sortir un mix mono n’est pas précisément ce que vous voulez faire, il y a plusieurs options alternatives. Premièrement, en utilisant l’option `mode:`, vous pouvez choisir de ressortir uniquement le signal d’entrée de gauche ou celui de droite vers la carte-son. Ou vous pouvez utiliser l’effet `:sound_out_stereo` pour ressortir vers les sorties de deux cartes-son consécutives. Consultez la documentation de la fonction pour davantage d’informations et des exemples.

## Sortie directe

Comme nous l’avons également vu, le comportement par défaut pour `:sound_out` et `:sound_out_stereo` pour les deux est d’envoyer leur audio à leur contexte externe (ce qui est typique de tous les FX) et à la sortie spécifiée de la carte de son. Cependant, vous pourriez occasionnellement vouloir seulement envoyer à la sortie de la carte de son et pas le contexte externe ( et donc ne pas avoir la possibilité que le son soit mélangé et envoyé aux canaux de sorties standards 1 et 2). Cela est possible en utilisation l’option standard FX `amp:` qui s’applique sur l’audio après que le FX ait manipulé l’audio :

    with_fx :sound_out, output: 3, amp: 0 do # B
      sample :loop_amen                      # A
    end

Dans l’exemple ci-dessus, l’échantillon `:loop_amen` est envoyé à son contexte extérieur, le FX `:sound_out`. Ensuite, cela envoie un mélange mono à la sortie 3 de la carte audio et multiplie l’audio par 0 ce qui le rend silencieux essentiellement. C’est le signal silencieux qui est par la suite envoyé au contexte extérieur de `:sound_out` qui est la sortie standard. Par conséquent, les canaux de sorties par défaut ne recevront aucun audio et le canal 3 recevra un mélange mono de tambours d’Amen Break.

# 99 - Conclusions

Ceci conclut ce tutoriel d’introduction à Sonic Pi. Nous espérons que vous avez appris quelque chose en cours de route. Ne vous inquiétez pas si vous pensez ne pas avoir tout compris - jouez simplement et prenez du plaisir, vous vous approprierez les choses à votre rythme. N’hésitez pas à replonger en arrière quand vous avez une question qui pourrait être couverte par une des sections.

Si vous avez des questions qui n’ont pas été couvertes dans le tutoriel, alors allez S.V.P. sur le forum de la communauté de Sonic Pi et posez vos questions là. Vous trouverez quelqu’un d’amical qui vous donnera un coup de main.

Enfin, je vous invite aussi à regarder en profondeur le reste de la documentation de ce système d’aide. Il y a un nombre de fonctionnalités qui n’ont pas été couvertes dans ce tutoriel et qui sont en attente de votre découverte.

Alors jouez, ayez du plaisir, partagez votre code, produisez-vous devant vos amis, montrez vos écrans et rappelez-vous :

Il n’y a pas d’erreurs, que des opportunités

Sam Aaron

# - Articles MagPi

L’appendice A rassemble tous les articles Sonic Pi écrits pour le magazine MagPi.

## Plongez dans les sujets

Ces articles ne sont pas destinés à être lus dans un ordre particulier et contiennent beaucoup de choses qui sont aussi dans le tutoriel. Plutôt que d’essayer de vous apprendre tout Sonic Pi, chacun se focalise plutôt sur un aspect particulier de Sonic Pi et le couvre d’une manière amusante et accessible.

## Lisez le MagPi

Vous les trouverez avec leur glorieuse présentation professionnelle dans les PDFs gratuits en téléchargement du MagPi ici : https://www.raspberrypi.org/magpi/

## Suggérez un sujet

Si vous ne trouvez pas de sujet qui vous intéresse parmi ceux couverts dans ces articles, pourquoi ne pas en suggérer un ? La manière la plus simple de faire cela est de tweeter votre suggestion à @Sonic_Pi. On ne sait jamais, votre suggestion sera peut-être le sujet du prochain article !

# - Les cinq meilleurs conseils

## 1. Il n’y a pas d’erreur

La plus importante leçon à apprendre avec Sonic Pi, c’est qu’il n’y a pas vraiment d’erreur. La meilleure façon d’apprendre, c’est juste d’essayer, essayer, et essayer. Essayez beaucoup de choses différentes, ne vous inquiétez pas de savoir si votre code sonne bien ou pas, et commencez par expérimenter avec le plus de synthés, de notes, d’effets et d’options possibles. Vous découvrirez beaucoup de choses qui vous feront rire parce qu’elles ne sonnent pas bien du tout et aussi quelques joyaux qui sonnent magnifiquement bien. Débarrassez-vous ensuite de ce que vous n’aimez pas et gardez les choses qui vous plaisent. Plus vous vous permettrez de faire des ‘erreurs’ et plus vite vous apprendrez et découvrirez votre son personnel de programmation interactive.

## 2. Utilisez les effets

Disons que vous maîtrisez déjà les bases de Sonic Pi pour créer des sons avec `sample` et `play`. Qu’est-ce qui vient ensuite ? Savez-vous que Sonic Pi supporte plus de 27 effets studio pour modifier le son de votre code ? Les effets sont comme des filtres pour images dans les programmes de dessin, mais à la place de rendre l’image floue ou noir et blanc, on peut ajouter de la réverbération, de la distorsion ou de l’écho à votre son. On peut voir ça comme brancher le câble d’une guitare dans une pédale d’effet de votre choix puis dans un ampli. Heureusement, Sonic Pi rend l’utilisation d’effets très simple et n’a pas besoin de câble ! Tout ce dont vous avez besoin c’est de choisir à quelle section de votre code ajouter l’effet puis de l’emballer avec le code de l’effet. Prenons un exemple. Disons que vous avez le code suivant :

    sample :loop_garzul
    16.times do
      sample :bd_haus
      sleep 0.5
    end

Si vous voulez ajouter un effet à l’échantillon `:loop_garzul`, il suffit de le mettre dans un bloc `with_fx` comme ceci :

    with_fx :flanger do
      sample :loop_garzul
    end
    16.times do
      sample :bd_haus
      sleep 0.5
    end

Maintenant, si voulez ajouter un effet au tambour basse, enveloppez-le aussi dans un `with_fx` :

    with_fx :flanger do
      sample :loop_garzul
    end
    with_fx :echo do
      16.times do
        sample :bd_haus
        sleep 0.5
      end
    end

Rappelez-vous, vous pouvez entourer n’importe quel code dans `with_fx` et tous les sons créés passeront dans cet effet.

## 3. Paramétrez vos synthés

Pour découvrir vraiment le son de votre code, vous voudrez bientôt savoir comment modifier et contrôler les synthés et effets. Par exemple, vous voudrez peut-être changer la durée d’une note, ajouter plus de réverb, ou changer la durée entre les échos. Heureusement, Sonic Pi vous donne un niveau de contrôle incroyable pour faire exactement cela avec des trucs appelés des paramètres optionnels ou opts pour faire court. Jetons-y un coup d’œil rapide. Copiez ce code dans un espace de travail et exécutez-le :

    sample :guit_em9

Oh, un joli son de guitare ! Commençons à jouer un peu avec. Et si on changeait son taux ?

    sample :guit_em9, rate: 0.5

Hé, qu’est-ce que ce `rate: 0.5` que j’ai ajouté à la fin ? C’est ce qu’on appelle une opt. Tous les synthés et effets de Sonic Pi les supportent et il y en a beaucoup avec lesquels on peut jouer. Ils sont disponibles pour les effets aussi. Essayez ceci :

    with_fx :flanger, feedback: 0.6 do
      sample :guit_em9
    end

Maintenant, essayez d’augmenter ce feedback à 1 pour entendre des sons de dingue ! Lisez la documentation pour des détails complets sur les nombreuses options à votre disposition.

## 4. Coder en direct

La meilleure manière d’expérimenter rapidement et d’explorer Sonic Pi est de coder de manière interactive. Cela vous permet de partir d’un peu de code et de le changer de manière continue pendant qu’il est en train de s’exécuter. Par exemple, si vous ne savez pas ce que le paramètre cutoff fait à un échantillon, jouez avec. Essayons ! Copiez ce code dans un de vos espaces de travail Sonic Pi :

    live_loop :experiment do
      sample :loop_amen, cutoff: 70
      sleep 1.75
    end

Maintenant, cliquez sur ‘Run’ et vous entendrez un rythme de batterie un peu étouffé. Maintenant, changez la valeur de `cutoff:` pour `80` et cliquez à nouveau sur ‘Run’. Entendez-vous la différence ? Essayez `90`, `100`, `110`…

Quand vous aurez pris la main à utiliser des `live_loop`, vous ne pourrez plus vous en passer. À chaque fois que je donne un concert de programmation interactive, je m’appuie autant sur `live_loop` qu’un batteur sur ses baguettes. Pour plus d’informations à propos de la programmation interactive, regardez la section 9 du tutoriel inclus.

## 5. Surfez sur les flux aléatoires

Enfin, une chose que j’adore faire est de tricher en faisant en sorte que Sonic Pi compose des choses pour moi. Une manière géniale de faire ça est d’utiliser l’aléation. Cela peut paraître compliqué, mais ça ne l’est pas du tout. Regardons. Copiez ceci dans un espace de travail :

    live_loop :rand_surfer do
      use_synth :dsaw
      notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
      16.times do
        play notes.choose, release: 0.1, cutoff: rrand(70, 120)
        sleep 0.125
      end
    end

Maintenant, quand vous jouez ceci, vous entendrez une suite continue de notes aléatoires de la gamme `:e2 :minor_pentatonic` jouée avec le synthé `:dsaw`. “Attendez, attendez ! Ce n’est pas une mélodie”, vous entends-je crier ! Eh bien, voici la première partie du tour de magie. Chaque fois que l’on recommence le `live_loop` on peut dire à Sonic Pi de réinitialiser la suite aléatoire à un point connu. C’est un peu comme voyager dans le temps dans le TARDIS avec le Docteur vers un point particulier du temps et de l’espace. Essayons ceci : ajoutez la ligne `use_random_seed 1` au `live_loop`:

    live_loop :rand_surfer do
      use_random_seed 1
      use_synth :dsaw
      notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
      16.times do
        play notes.choose, release: 0.1, cutoff: rrand(70, 120)
        sleep 0.125
      end
    end

Maintenant, chaque fois que la boucle `live_loop` tourne, la suite aléatoire est réinitialisée. Ceci signifie qu’elle contient exactement les même 16 notes à chaque fois. Et voilà ! Une mélodie de composée. Et maintenant, voici la partie vraiment excitante. Changez la valeur de graine de `1` pour un autre nombre. Par exemple `4923`. Ouaouh, une autre mélodie ! Donc, en changeant uniquement un nombre (la graine aléatoire), on peut explorer autant de combinaisons mélodiques qu’on peut imaginer ! C’est ça la magie du code.

# - Programmation interactive (Live Coding)

Les rayons lasers perçaient à travers les bouffées de fumée et les baffles transmettaient des basses profondes dans les corps de la foule. L’atmosphère était remplie d’un mélange de synthés et de danse. Il y avait pourtant quelque chose d’étrange dans cette boîte de nuit. Du texte futuriste était projeté au dessus de la cabine du DJ, bougeant, dansant, clignotant. Ce n’étaient pas de belles visualisations, c’était juste une projection de Sonic Pi tournant sur un Raspberry Pi. La personne dans la cabine de DJ n’était pas en train de tourner des disques, elle écrivait, éditait et évaluait du code. En direct. C’est ça le Live Coding.

Cela peut sonner comme une histoire tirée par les cheveux dans une boîte de nuit futuriste mais coder de la musique comme cela est une tendance qui se développe et qu’on appelle souvent Live Coding (programmation interactive) (http://toplap.org). Une des directions récentes que cette approche de la musique a prise est l’Algorave (http://algorave.com) : des événements où des artistes comme moi codent de la musique pour que les gens dansent. Cependant vous n’avez pas besoin d’une boîte de nuit pour coder en live : avec Sonic Pi version 2.6 et plus vous pouvez le faire dans n’importe quel endroit où vous pouvez prendre votre Raspberry Pi et un casque ou des haut-parleurs. Quand vous aurez atteint la fin de cet article, vous saurez programmez vos rythmes et les modifier en direct. Où vous irez ensuite ne sera limité que par votre imagination.

## Boucle interactive

La clef de la programmation interactive avec Sonic Pi est la maîtrise de la `live_loop`. En voici une :

    live_loop :beats do
      sample :bd_haus
      sleep 0.5
    end

Il y a quatre ingrédients principaux dans une `live_loop`. Le premier est son nom. Notre `live_loop` s’appelle ici `:beats`. Vous pouvez donner le nom que vous voulez à votre `live_loop`. Défoulez-vous. Soyez créatifs. J’utilise souvent des noms qui communiquent sur ce que la musique va donner à l’audience. Le deuxième ingrédient est le mot `do` qui marque l’endroit où la `live_loop` commence. Le troisième est le mot `end` qui marque celui où la `live_loop` s’arrête, et enfin il y a le corps de la `live_loop` qui décrit ce que la boucle va répéter : c’est la partie entre `do` et `end`. Dans ce cas on joue en boucle un sample de tambour basse et on attend un demi temps. Cela produit un beau rythme régulier de basse. Allez-y, copiez-le dans un buffer vide de Sonic Pi et cliquez sur ‘Run’. Boum, boum, boum !.

## Redéfinir à la volée

OK, qu’est-ce qu’elle a de si spécial, cette `live_loop` ? Jusqu’ici, on dirait que c’est juste une boucle idéalisée ! Eh bien, la beauté des `live_loop`, c’est qu’on peut les redéfinir à la volée. Ceci signifie que, pendant qu’elles sont en train de tourner, on peut changer ce qu’elles font. C’est le secret de la programmation interactive avec Sonic Pi. Essayons :

    live_loop :choral_drone do
      sample :ambi_choir, rate: 0.4
      sleep 1
    end

Maintenant cliquez le bouton ‘Run’ ou tapez ‘alt-r’. Vous entendez maintenant de beaux sons de chœurs . Ensuite, alors qu’il est encore en train de jouer, changez la fréquence de `0.4` en `0.38`. Cliquez à nouveau sur ‘Run’. Whaou ! Vous avez entendu le chœur changer de note ? Ecrivez à nouveau `0.4` pour revenir comme avant. Puis `0.2`, puis `0.19`, puis à nouveau `0.4`. Voyez-vous que juste en changeant un paramètre à la volée permet de contrôler la musique ? Maintenant jouez vous-même avec la fréquence, choisissez vos propres valeurs. Essayez des nombres négatifs, de très petits nombres et de grands nombres. Amusez-vous !

## Il est important de dormir

Une des leçons les plus importantes avec les `live_loop`, c’est qu’elles ont besoin de se reposer. Prenons par exemple cette `live_loop`:

    live_loop :infinite_impossibilities do
      sample :ambi_choir
    end

Si vous essayez d’exécuter ce code, vous verrez immédiatement que Sonic Pi se plaint que la `live_loop` n’a pas dormi. C’est un mécanisme de sécurité qui se met en place. Prenons un moment pour penser à ce que ce code demande à l’ordinateur de faire. C’est cela, on demande à l’ordinateur de jouer un nombre infini de samples de chorale dans un temps nul. Sans le mécanisme de sécurité le pauvre ordinateur essaierait de faire ça et exploserait. Souvenez-vous en bien : vos `live_loop`s doivent contenir un appel à `sleep`.

## Combiner des sons

La musique est pleine de choses qui arrivent en même temps. La batterie en même temps que la basse, en même temps que du chant, en même temps que des guitares… En informatique on appelle ça la concurrence et Sonic Pi nous donne une manière étonnamment simple de jouer des choses en même temps. Il suffit d’utiliser plus qu’une `live_loop` !

    live_loop :beats do
      sample :bd_tek
      with_fx :echo, phase: 0.125, mix: 0.4 do
        sample  :drum_cymbal_soft, sustain: 0, release: 0.1
        sleep 0.5
      end
    end
    live_loop :bass do
      use_synth :tb303
      synth :tb303, note: :e1, release: 4, cutoff: 120, cutoff_attack: 1
      sleep 4
    end

Ici nous avons deux `live_loop`s, une qui tourne rapidement pour faire un rythme, et une autre qui boucle lentement pour faire un son de basse de fou.

Une des choses intéressantes quand on utilise plusieurs `live_loop`, c’est que chacune gère son propre temps. Cela signifie qu’il est très facile de créer des structures polyrythmiques intéressantes et même de jouer avec la phase, style Steve Reich. Par exemple :

    # La phase de piano de Steve Reich
    notes = (ring :E4, :Fs4, :B4, :Cs5, :D5, :Fs4, :E4, :Cs5, :B4, :Fs4, :D5, :Cs5)
    live_loop :slow do
      play notes.tick, release: 0.1
      sleep 0.3
    end
    live_loop :faster do
      play notes.tick, release: 0.1
      sleep 0.295
    end

## Rassemblons tout

Dans chacun de ces tutoriels, nous finirons avec un exemple qui montre un nouveau morceau de musique qui utilise toutes les idées introduites. Lisez ce code et essayez d’imaginer ce qu’il fait. Ensuite, copiez-le dans un buffer frais de Sonic Pi et cliquez ‘Run’ pour entendre comment il sonne. Enfin changez un des nombres ou commentez / décommentez des parties. Voyez si vous pouvez prendre ça comme point de départ d’une nouvelle performance, et surtout amusez-vous ! A la prochaine…

    with_fx :reverb, room: 1 do
      live_loop :time do
        synth :prophet, release: 8, note: :e1, cutoff: 90, amp: 3
        sleep 8
      end
    end
    live_loop :machine do
      sample :loop_garzul, rate: 0.5, finish: 0.25
      sample :loop_industrial, beat_stretch: 4, amp: 1
      sleep 4
    end
    live_loop :kik do
      sample :bd_haus, amp: 2
      sleep 0.5
    end
    with_fx :echo do
      live_loop :vortex do
        # use_random_seed 800
        notes = (scale :e3, :minor_pentatonic, num_octaves: 3)
        16.times do
          play notes.choose, release: 0.1, amp: 1.5
          sleep 0.125
        end
      end
    end

# - Rythmes codés

Une des évolutions techniques les plus excitantes et disruptives dans la musique moderne a été l’invention des samplers. C’étaient des boîtes qui permettaient d’enregistrer n’importe quels sons dedans et de les manipuler et jouer de nombreuses manières intéressantes. Par exemple, on pouvait prendre un vieux disque, trouver un solo de batterie (ou un break), l’enregistrer dans le sampler et ensuite le jouer deux fois moins vite pour créer la fondation de vos derniers rythmes. C’est ainsi que la musique hip-hop est née et aujourd’hui il est presque impossible de trouver de la musique électronique qui n’incorpore pas de samples. Utiliser des samples est une très bonne manière d’introduire facilement des éléments nouveaux et intéressants dans vos performances de live coding.

Comment pouvez-vous vous procurer un sampler ? Eh bien, vous en avez déjà un : c’est votre Raspberry Pi ! L’application de live coding Sonic Pi comprend un sampler très puissant. Jouons avec !

## Le break Amen

Un des samples de break de batterie les plus classiques et reconnaissables s’appelle le break Amen. Il a été joué pour la première fois en 1969 dans la chanson “Amen Brother” des Winstons dans un break de batterie. Cependant c’est quand il a été découvert par les premiers musiciens de hip-hop dans les années 80 et utilisé dans des samplers qu’il a commencé à être très utilisé dans des styles aussi variés que le drum and bass, le breakbeat, la techno hardcore et le breakcore.

Je suis sûr que vous êtes ravis d’entendre qu’il est aussi inclus dans Sonic Pi. Choisissez un tampon vide et copiez-y ce code :

    sample :loop_amen

Cliquez sur Run et boum ! Vous entendez l’un des breaks de batterie les plus influents de l’histoire de la musique dance. Ceci dit, cet échantillon n’a pas été célèbre pour être joué juste une seule fois, il a été fait pour être joué en boucle.

## Étirer des rythmes

Jouons le break Amen en boucle en utilisant notre vieille amie la `live_loop`, introduite dans le tutoriel du mois dernier :

    live_loop :amen_break do
      sample :loop_amen
      sleep 2
    end

OK, ça boucle, mais il y a une pause ennuyeuse à chaque fois. C’est parce qu’on a demandé d’attendre `2` temps et avec le nombre par défaut de 60 BPM (battements par minute), le sample `:loop_amen` ne dure que `1.753` temps. Nous avons donc un silence de `2 - 1.753 = 0.247` temps. Même s’il est court, c’est notable.

Pour corriger ce problème, on peut utiliser l’option `beat_stretch:` pour demander à Sonic Pi d’étirer (ou de rétrécir) l’échantillon pour correspondre au nombre de beat spécifié.

Les fonctions `sample` et `synth` de Sonic Pi vous donnent beaucoup de contrôle via des paramètres optionnels comme `amp:`, `cutoff:` et `release:`. Cela dit le terme `paramètre optionnel` est très long à dire donc on les appelle juste opts pour rester simple.

    live_loop :amen_break do
      sample :loop_amen, beat_stretch: 2
      sleep 2
    end

Maintenant on peut danser ! Quoique, peut-être qu’on veut l’accélérer ou le ralentir en fonction de l’ambiance.

## Jouer avec le temps

OK, et si on voulait changer de style pour faire du hip hop old school ou du breakcore ? Une manière simple de faire ça est de jouer avec le temps : ou en d’autres mots jouer avec le tempo. C’est très facile avec Sonic Pi : il suffit d’appeler `use_bpm` dans votre boucle interactive :

    live_loop :amen_break do
      use_bpm 30
      sample :loop_amen, beat_stretch: 2
      sleep 2
    end

Pendant que vous rappez sur ces rythmes lents, remarquez que nous avons toujours un repos de 2 et que notre BPM vaut 30, mais tout est bien synchronisé. L’option `beat_stretch` fonctionne avec le BPM courant pour s’assurer que tout fonctionne bien.

Maintenant, voici la partie amusante. Pendant que la boucle est en train de tourner, changez le `30` dans la ligne `use_bpm 30` en `50`. Waouh, tout est devenu plus rapide, mais reste synchronisé - Essayer encore d’accélérer jusqu’à 80, jusqu’à 120, ou même, soyons fous, 200 !

## Filtrage

Maintenant qu’on peut jouer des échantillons en boucle de manière interactive, jetons un œil aux options les plus amusantes proposées par le synthé `sample`. La première est le `cutoff:` qui contrôle le filtre de coupure de l’échantillonneur. Par défaut, il est désactivé mais on peut facilement l’activer :

    live_loop :amen_break do
      use_bpm 50
      sample :loop_amen, beat_stretch: 2, cutoff: 70
      sleep 2
    end

Allez-y, changez la valeur de l’option `cutoff:`. Par exemple, montez-la à 100, cliquez sur Run, et attendez que la prochaine boucle arrive pour entendre la différence dans le son. Remarquez que des valeurs basses comme 50 sonnent plus doux et bas, et que des hautes valeurs comme 100 ou 120 sonnent plus rempli et râpeux. C’est parce que l’option `cutoff:` va couper les parties de haute-fréquence du son tout comme une tondeuse coupe le haut de la pelouse. L’option `cutoff:` est comme le réglage de la longueur : cela détermine combien il reste d’herbe.

## Découpage/tranchage

Un autre super outil avec lequel on peut jouer est l’effet slicer. Il va découper le son en tranches. Encadrez la ligne `sample` avec le code de l’effet ainsi :

    live_loop :amen_break do
      use_bpm 50
      with_fx :slicer, phase: 0.25, wave: 0, mix: 1 do
        sample :loop_amen, beat_stretch: 2, cutoff: 100
      end
      sleep 2
    end

Remarquez comme le son bondit un peu plus de haut en bas. (Vous pouvez entendre le son original sans l’effet en changeant l’option `mix:` en `0`.) Maintenant essayez de modifier la valeur de l’option `phase:`. C’est la fréquence (en battements) de l’effet de coupe. Une plus petite valeur comme `0.125` va couper plus rapidement et une plus grande valeur comme `0.5` va couper plus lentement. Remarquez que si on divise ou multiplie successivement par deux l’option `phase:` cela sonne généralement bien. Enfin, choisissez une valeur pour l’option `wave:` entre 0, 1 et 2 et écoutez comment le son change. Ce sont différentes formes d’onde. 0 est une onde scie (elle commence fort et finit en fondu), 1 est une onde carrée (commence fort et finit fort) et 2 est une onde en triangle (commence en fondu, finit en fondu).

## Rassemblons tout

Enfin, revenons dans le temps et revisitons la jeune scène de drum and bass de Bristol avec l’exemple du mois. Ne vous inquiétez pas trop de tout ce que cela signifie, tapez le, cliquez sur Run, puis commencez à coder interactivement en changeant les valeurs des options et voyez où cela vous amène. Partagez ce que vous créez ! À la prochaine…

    use_bpm 100
    live_loop :amen_break do
      p = [0.125, 0.25, 0.5].choose
      with_fx :slicer, phase: p, wave: 0, mix: rrand(0.7, 1) do
        r = [1, 1, 1, -1].choose
        sample :loop_amen, beat_stretch: 2, rate: r, amp: 2
      end
      sleep 2
    end
    live_loop :bass_drum do
      sample :bd_haus, cutoff: 70, amp: 1.5
      sleep 0.5
    end
    live_loop :landing do
      bass_line = (knit :e1, 3, [:c1, :c2].choose, 1)
      with_fx :slicer, phase: [0.25, 0.5].choose, invert_wave: 1, wave: 0 do
        s = synth :square, note: bass_line.tick, sustain: 4, cutoff: 60
        control s, cutoff_slide: 4, cutoff: 120
      end
      sleep 4
    end

# - Riffs de synthés

Que ce soit la dérive hantée d’oscillateurs grondants ou le coup de poing désaccordé des ondes scies perçant à travers le mix, le synthétiseur principal joue un rôle essentiel dans chaque piste électronique. Dans l’édition du mois dernier de cette série de tutoriels nous avons couvert comment coder nos rythmes. Dans ce tutoriel nous verrons comment coder les trois composants principaux d’un riff de synthétiseur : le timbre, la mélodie et le rythme.

OK, allumez votre Raspberry Pi, ouvrez Sonic Pi (version 2.6 ou ultérieure) et faisons du bruit !

## Les possibilités de timbres

Une partie essentielle de n’importe quel riff de synthétiseur est de changer et de jouer avec le timbre des sons. On peut contrôler le timbre dans Sonic Pi de deux manières : en choisissant différents synthétiseurs pour un changement dramatique et en définissant les diverses options des synthétiseurs pour des modifications plus subtiles. On peut aussi utiliser des effets, mais ce sera pour un autre tutoriel…

Créons une boucle interactive simple où l’on modifiera en continu le synthé courant :

    live_loop :timbre do
      use_synth (ring :tb303, :blade, :prophet, :saw, :beep, :tri).tick
      play :e2, attack: 0, release: 0.5, cutoff: 100
      sleep 0.5
    end

Regardez ce code. On ne fait que parcourir (avec `tick`) un anneau de noms de synthétiseurs (on boucle sur chacun d’eux à leur tour ce qui répète la liste encore et encore). On passe le nom de ce synthétiseur à la fn (fonction) `use_synth`, ce qui changera le synthétiseur courant de la `live_loop`. On joue aussi la note `:e2` (E (ou Mi) à la deuxième octave), avec un temps de relâche de 0.5 battement (une demi seconde au BPM par défaut , qui est de 60) et avec l’option `:cutoff` fixée à 100.

Écoutez comme les différents synthétiseurs font des sons très différents même s’ils jouent tous la même note. Maintenant expérimentez et amusez-vous. Changez le temps de relâche en lui donnant des valeurs plus grandes et plus petites. Par exemple, changez les options `attack:` et `release:` pour voir comme des temps différents de fondu d’entrée et de sortie ont un grand effet sur le son. Enfin changez l’option `cutoff:` pour voir comment différentes valeurs de coupure ont une influence massive sur le timbre (des valeurs entre 60 et 130 sont bonnes). Voyez combien de sons vous pouvez créer juste en changeant quelques valeurs. Une fois que vous maîtrisez cela, allez dans l’onglet Synthés dans le système d’aide pour voir la liste entière des synthétiseurs et des options que chacun d’eux supporte pour voir l’étendue du pouvoir que vous avez au bouts de vos doigts de codeur.

## Timbre

Le timbre est juste un mot savant pour décrire comment sonne un son. Si vous jouez la même note avec différents instruments comme un violon, une guitare, ou un piano, la fréquence (si elle sonne haut ou bas) sera la même, mais la qualité du son sera différente. La qualité du son, ce qui fait qu’on peut différencier un piano et une guitare, c’est le timbre.

## Composition mélodique

Un autre aspect important de notre synthé principal est le choix de notes que l’on veut jouer. Si vous avez déjà une idée précise, alors vous pouvez simplement créer un anneau avec vos notes et les parcourir :

    live_loop :riff do
      use_synth :prophet
      riff = (ring :e3, :e3, :r, :g3, :r, :r, :r, :a3)
      play riff.tick, release: 0.5, cutoff: 80
      sleep 0.25
    end

Ici nous avons défini notre mélodie avec un anneau qui inclut des notes comme `:e3` et des silences représentés par `:r`. Nous utiliserons ensuite `.tick` pour jouer chaque note à son tour, ce qui nous donne un riff qui se répète.

## Mélodie automatique

Ce n’est pas toujours facile d’inventer un riff sympa. C’est souvent plus simple de demander à Sonic Pi une sélection de riffs aléatoires et de choisir celui que l’on préfère. Pour faire cela on doit combiner trois choses : des anneaux, de l’aléatoire et des graines aléatoires. Regardons un exemple :

    live_loop :random_riff do
      use_synth :dsaw
      use_random_seed 3
      notes = (scale :e3, :minor_pentatonic).shuffle
      play notes.tick, release: 0.25, cutoff: 80
      sleep 0.25
    end

Plusieurs choses se passent ; regardons les une par une. Tout d’abord, nous spécifions que nous utilisons la graine aléatoire 3. Qu’est-ce que cela signifie ? Et bien, ce qui est utile, c’est que lorsque nous paramétrons la graine, nous pouvons prédire quelle sera la prochaine valeur aléatoire ; c’est la même que la dernière fois que nous avons paramétré la graine à 3 ! Une autre chose utile à savoir est que le mélange d’un anneau de notes fonctionne de la même façon. Dans l’exemple ci-dessus, c’est comme si on demandait le ‘troisième mélange’ dans la liste standard de mélanges ; qui est aussi le même chaque fois que nous paramétrons toujours la même valeur de la graine aléatoire avant le mélange. Enfin, nous ne faisons que passer les notes mélangées pour jouer le riff.

Maintenant, c’est ici que nous commençons à nous amuser. Si nous changeons la valeur aléatoire de la graine pour un autre nombre, disons 3000, nous obtenons un mélange entièrement différent des notes. Il est donc maintenant extrêmement facile d’explorer de nouvelles mélodies. Il suffit de choisir la liste de notes que l’on veut mélanger (les gammes sont un excellent point de départ) et ensuite de choisir la graine avec laquelle nous voulons les mélanger. Si nous n’aimons pas la mélodie, changez simplement l’une de ces deux choses et essayer à nouveau. Répétez jusqu’à ce que vous aimiez ce que vous entendez !

## Pseudo aléatoire

L’aléatoire de Sonic Pi n’est pas vraiment aléatoire, on appelle ça du pseudo aléatoire. Imaginez que vous jetez un dé 100 fois et que vous écrivez le résultat de chaque jet sur une feuille de papier. Sonic Pi a l’équivalent de cette liste de résultats qu’il utilise quand on demande une valeur aléatoire. Au lieu de jeter un vrai dé, il prend juste la valeur suivante dans la liste. Définir la graine aléatoire revient à sauter à un endroit particulier de cette liste.

## Trouver votre rythme

Un autre aspect important de notre riff est le rythme ; quand jouer une note et quand ne pas jouer. Comme nous l’avons vu plus haut, nous pouvons utiliser `:r` dans nos anneaux pour insérer des silences. Une autre manière très puissante consiste à utiliser des ‘spreads’ que nous aborderons dans un prochain tutoriel. Aujourd’hui, nous allons utiliser l’aléation pour nous aider à trouver notre rythme. Au lieu de jouer chaque note, nous pouvons utiliser un conditionnel pour jouer une note avec une probabilité donnée. Jetons un coup d’œil :

    live_loop :random_riff do
      use_synth :dsaw
      use_random_seed 30
      notes = (scale :e3, :minor_pentatonic).shuffle
      16.times do
        play notes.tick, release: 0.2, cutoff: 90 if one_in(2)
        sleep 0.125
      end
    end

Une fonction vraiment utile à connaître est `one_in` qui nous donnera une valeur `true` ou `false` (vrai ou faux) avec la probabilité spécifiée. Ici, nous utilisons une valeur de 2, donc en moyenne un appel sur deux à `one_in` retournera `true`. En d’autres termes, 50% du temps elle retournera `true`. Si on choisit des valeurs plus grandes, elle retournera `false` plus souvent ce qui mettra plus d’espace dans notre riff.

Remarquez que nous avons ajouté quelques itérations ici avec `16.times`. C’est parce que nous voulons seulement réinitialiser notre valeur de graine aléatoire toutes les 16 notes afin que notre rythme se répète toutes les 16 fois. Cela n’affecte pas le mélange puisqu’il est toujours fait immédiatement après avoir défini la graine. Nous pouvons utiliser la taille d’itération pour modifier la longueur du riff. Essayez de changer le 16 en 8, ou même en 4, ou 3, et voyez comment cela affecte le rythme du riff.

## Rassemblons tout

OK, combinons tout ce que nous avons appris dans un dernier exemple. À la prochaine !

    live_loop :random_riff do
      #  uncomment to bring in:
      #  synth :blade, note: :e4, release: 4, cutoff: 100, amp: 1.5
      use_synth :dsaw
      use_random_seed 43
      notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle.take(8)
      8.times do
        play notes.tick, release: rand(0.5), cutoff: rrand(60, 130) if one_in(2)
        sleep 0.125
      end
    end

    live_loop :drums do
      use_random_seed 500
      16.times do
        sample :bd_haus, rate: 2, cutoff: 110 if rand < 0.35
        sleep 0.125
      end
    end

    live_loop :bd do
      sample :bd_haus, cutoff: 100, amp: 3
      sleep 0.5
    end

# - Acid Bass

Il est impossible de parcourir l’histoire de la musique de danse électronique sans voir l’énorme impact du minuscule synthétiseur Roland TB-303. C’est la sauce secrète derrière le son de basse acide original. Ces riffs de basse TB-303 qui grincent et étouffent peuvent être entendus depuis la première scène de Chicago House jusqu’aux artistes électroniques plus récents tels que Plastikman, Squarepusher et Aphex Twin.

Il est intéressant de noter que Roland n’a jamais eu l’intention d’utiliser le TB-303 dans la musique de danse. Il a été créé à l’origine pour aider les guitaristes à s’exercer. Ils imaginaient que les gens les programmeraient pour qu’ils jouent des lignes de basse d’accompagnement pour jammer. Malheureusement, il y avait un certain nombre de problèmes : ils étaient un peu compliqués à programmer, ne sonnaient pas particulièrement bien pour remplacer une guitare basse et étaient assez chers à l’achat. Décidant d’arrêter les frais, Roland a cessé de les fabriquer après la vente de 10000 unités et, après quelques années passées sur les étagères des guitaristes, ils se sont rapidement retrouvés dans les vitrines des magasins d’occasion. Ces TB-303 solitaires et abandonnés attendaient d’être découverts par une nouvelle génération d’expérimentateurs qui ont commencé à les utiliser d’une manière que Roland n’avait pas imaginée pour créer de nouveaux sons fous. La Acid House était née.

Bien que mettre la main sur un TB-303 original ne soit pas si facile, vous serez heureux d’apprendre que vous pouvez transformer votre Raspberry Pi en TB-303 en utilisant la puissance de Sonic Pi. Lancez Sonic Pi, copiez ce code dans un tampon vide, et cliquez sur ‘Run’ :

    use_synth :tb303
    play :e1

De l’Acid Bass instantané ! Jouons un peu…

## Écrasez cette basse

Commençons par construire un arpégiateur interactif pour rendre les choses amusantes. Dans le dernier tutoriel, nous avons vu comment des mélodies peuvent n’être qu’un anneau de notes que nous parcourons les unes après les autres, en répétant quand nous arrivons à la fin. Créons une boucle interactive qui fait exactement cela :

    use_synth :tb303
    live_loop :squelch do
      n = (ring :e1, :e2, :e3).tick
      play n, release: 0.125, cutoff: 100, res: 0.8, wave: 0
      sleep 0.125
    end

Jetez un œil à chaque ligne.

1. À la première ligne, choisissons `tb303` comme synthé par défaut avec la fonction `use_synth`.
2. À la deuxième ligne, créons une boucle interactive du nom de `:squelch` qui va juste boucler encore et encore.
3. La troisième ligne est l’endroit où nous créons notre riff : un anneau de notes (Mi dans les octaves 1, 2, et 3) que nous parcourons simplement avec `.tick'. Nous définissons` n’ pour représenter la note courante dans le riff. Le signe égal signifie qu’il suffit d’assigner la valeur à droite au nom à gauche. Ce sera différent à chaque boucle. La première fois, `n' sera réglé sur` :e1`. La deuxième fois, ce sera` :e2`, suivi de` :e3`, puis retour à` :e1`, en bouclant à l’infini.
4. La ligne quatre est l’endroit où l’on déclenche notre synthé `:tb303`. On lui passe quelques options intéressantes : `release:`, `cutoff:`, `res:` et `wave:` que l’on décrira plus bas.
5. La ligne cinq est notre `sleep` : on demande à la boucle interactive de boucler toutes les `0.125`secondes ou 8 fois par seconde au BPM par défaut de 60.
6. La ligne six est la fin (NdT : `end`) de la boucle interactive. Le mot `end` indique précisément à Sonic Pi où se termine la boucle interactive.

Alors que vous êtes encore en train de vous familiariser avec ce qui se passe, tapez le code ci-dessous et cliquez sur le bouton ‘Run’. Vous devriez entendre le `:tb303` entrer en action. C’est ici le cœur de l’action : commençons la programmation interactive.

Pendant que la boucle tourne, changez l’option `cutoff:` pour `110`. Puis cliquez à nouveau sur le bouton ‘Run’. Vous devriez entendre le son devenir un peu plus dur et sec. Montez à `120` et cliquez sur ‘Run’. Puis `130`. Écoutez comme les valeurs hautes de coupure (NdT : `cutoff`) rendent le son plus perçant et intense. Enfin, descendez à `80` quand vous sentirez qu’il vous faut un peu de repos. Puis répétez ça autant que vous voulez. Pas d’inquiétude, je serai toujours là…

Une autre option avec laquelle ça vaut le coup de jouer est `res:`. Elle contrôle le niveau de résonance du filtre. Une résonance haute est caractéristique des sons de basse acide. Nous avons pour le moment une `res:` de `0.8`. Essayez de la monter à `0.85`, puis `0.9`, et enfin `0.95`. Vous pourriez trouver qu’un filtre de coupure à `110` ou plus haut peut permettre d’entendre plus facilement les différences. Enfin défoulez-vous et montez jusque `0.999` pour avoir des sons déments. Avec une `res` aussi haute, vous entendez tellement le filtre de coupure résonner qu’il commencera à faire ses propres sons !

Enfin, pour avoir un grand impact sur le timbre, essayez de mettre l’option `wave:` à `1`. C’est le choix de l’oscillateur source. La valeur par défaut est `0` ce qui est une onde en dents de scie. `1` est une onde pulsée, et `2` est une onde en triangle.

Bien sûr, essayez différentes mélodies en changeant les notes dans l’anneau ou même en choisissant des notes de gammes ou d’accords. Amusez-vous bien avec votre premier synthé de basse acide.

## Déconstruisons le TB-303

Le design du TB-303 original était en fait assez simple. Comme vous pouvez le voir sur le diagramme suivant, il n’y a que quatre parties principales.

Tout d’abord, il y a l’onde oscillatoire - les ingrédients de base du son. Dans ce cas, nous avons une onde carrée. Ensuite, il y a l’enveloppe d’amplitude de l’oscillateur qui contrôle l’amplitude de l’onde carrée au cours du temps. On peut y accéder dans Sonic Pi avec les options `attack:`, `decay:`, `sustain:` et `release:` ainsi qu’à leurs niveaux correspondant. Pour plus d’informations, lisez la Section 2.4 ‘Durée avec les enveloppes’ dans le tutoriel intégré. Nous passons ensuite notre onde carrée enveloppée à travers un filtre passe-bas résonant. Cela coupe les hautes fréquences tout en ayant un bel effet de résonance. C’est ici que le plaisir commence. La valeur de coupure de ce filtre est également contrôlée par sa propre enveloppe ! Cela signifie que nous avons un contrôle incroyable sur le timbre du son en jouant avec ces deux enveloppes. Jetons un coup d’œil :

    use_synth :tb303
    with_fx :reverb, room: 1 do
      live_loop :space_scanner do
        play :e1, cutoff: 100, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
        sleep 8
      end
    end

Pour chaque option d’enveloppe standard, il y a une option équivalente `cutoff_' dans le synthétiseur` :tb303’. Donc, pour changer le temps d’attaque de coupure, nous pouvons utiliser l’option `cutoff_attack:`. Copiez le code ci-dessus dans un tampon vide et cliquez sur ‘Run’. Vous entendrez un bruit de gazouillis fou qui rentre et qui sort. Maintenant, commencez à jouer. Essayez de changer la durée de `cutoff_attack:` en `1' puis` 0.5’. Maintenant, essayez `8`.

Remarquez que j’ai passé tout cela à travers un effet `:reverb` pour plus d’atmosphère - essayez d’autres effets pour voir ce qui fonctionne !

## Rassemblons tout

Enfin, voici un morceau que j’ai composé en utilisant les idées de ce tutoriel. Copiez-le dans un tampon vide, écoutez-le pendant un moment, puis commencez à coder interactivement vos propres modifications. Voyez quels sons fous vous pouvez en faire ! À la prochaine….

    use_synth :tb303
    use_debug false

    with_fx :reverb, room: 0.8 do
      live_loop :space_scanner do
        with_fx :slicer, phase: 0.25, amp: 1.5 do
          co = (line 70, 130, steps: 8).tick
          play :e1, cutoff: co, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
          sleep 8
        end
      end

      live_loop :squelch do
        use_random_seed 3000
        16.times do
          n = (ring :e1, :e2, :e3).tick
          play n, release: 0.125, cutoff: rrand(70, 130), res: 0.9, wave: 1, amp: 0.8
          sleep 0.125
        end
      end
    end

# - Minecraft musical

Avertissement d’obsolescence Désolé mais cet article avait été réécrit quand l’Édition Minecraft Pi faisait encore partie du Système d’Exploitation Raspberry Pi et que Sonic Pi avait construit un support pour le contrôler avec du code. Malheureusement ce n’est plus le cas et le code spécifique à minecraft (les fonctions `mc_*`) n’est plus disponible dans Sonic Pi. Cependant, cet article est laissé ici comme un souvenir de ce qui était autrefois possible.

Bonjour et bon retour parmi nous ! Dans les tutoriels précédents, nous nous sommes concentrés uniquement sur les possibilités musicales de Sonic Pi, en transformant votre Raspberry Pi en un instrument de musique prêt à jouer. Jusqu’à présent, nous avons appris comment :

- Programmation interactive - en changeant les sons à la volée,
- Coder des rythmes imposants,
- Générer des mélodies de synthé puissantes,
- Recréer le fameux son de basse acide TB-303.

Il y a tant d’autres choses à vous montrer (que nous explorerons dans les prochaines éditions). Cependant, ce mois-ci, regardons quelque chose que Sonic Pi peut faire que vous n’avez probablement pas remarqué : contrôler Minecraft.

## Bonjour, monde de Minecraft

D’accord, commençons. Démarrez votre Raspberry Pi, lancez Minecraft Pi et créez un nouveau monde. Maintenant, démarrez Sonic Pi, redimensionnez et déplacez vos fenêtres de manière à pouvoir voir Sonic Pi et Minecraft Pi en même temps.

Dans un tampon disponible, tapez ce qui suit :

    mc_message "Hello Minecraft from Sonic Pi!"

Maintenant, cliquez sur ‘Run’. Boum ! Votre message est apparu dans Minecraft ! C’était facile, non ? Maintenant, arrêtez un moment de lire ceci et jouez un peu avec vos propres messages. Amusez-vous !

## Téléportation sonique

Maintenant, faisons un peu d’exploration. L’option standard est d’attraper la souris et le clavier et de commencer à se promener. Ça fonctionne, mais c’est plutôt lent et ennuyeux. Il vaudrait mieux qu’on ait une sorte de téléporteur. Eh bien, grâce à Sonic Pi, nous en avons un. Essayez ceci :

    mc_teleport 80, 40, 100

Oh ! C’était une longue ascension. Si vous n’étiez pas en mode de vol, vous seriez retombé jusqu’au sol. Si vous tapez deux fois sur la touche Espace pour entrer en mode vol et vous téléporter à nouveau, vous resterez en vol stationnaire à l’endroit où vous vous êtes déplacés.

Que signifient ces chiffres ? Nous avons trois nombres qui décrivent les coordonnées de l’endroit du monde où nous voulons nous déplacer. Nous donnons un nom à chacun de ces numéros - x, y et z :

- x - la distance à gauche et à droite (80 dans notre exemple)
- y - la hauteur que nous voulons atteindre (40 dans notre exemple)
- z - la distance avant et arrière (100 dans notre exemple)

En choisissant des valeurs différentes pour x, y et z, nous pouvons nous téléporter n’importe où dans notre monde. Essayez ! Choisissez différents nombres et voyez où vous pouvez vous retrouver. Si l’écran devient noir, c’est que vous vous êtes téléporté sous terre ou dans une montagne. Il suffit de choisir une valeur y plus élevée pour revenir au dessus de la terre. Continuez à explorer jusqu’à ce que vous trouviez un endroit qui vous plaise….

En utilisant les idées vues jusqu’ici, construisons un téléporteur sonique qui fera un son de téléportation amusant pendant qu’il nous propulsera à travers le monde de Minecraft :

    mc_message "Preparing to teleport...."
    sample :ambi_lunar_land, rate: -1
    sleep 1
    mc_message "3"
    sleep 1
    mc_message "2"
    sleep 1
    mc_message "1"
    sleep 1
    mc_teleport 90, 20, 10
    mc_message "Whoooosh!"

## Blocs magiques

Maintenant que vous avez trouvé un bel endroit, commençons à construire. Vous pourriez faire comme vous en avez l’habitude et commencer à cliquer furieusement avec la souris pour placer des blocs sous le curseur. Ou vous pouvez employer la magie de Sonic Pi. Essayez ceci :

    x, y, z = mc_location
    mc_set_block :melon, x, y + 5, z

Maintenant, regardez en l’air ! Il y a un melon dans le ciel ! Prenez un moment pour regarder le code. Qu’est-ce qu’on a fait ? Sur la première ligne, nous avons saisi l’emplacement actuel de Steve dans les variables x, y et z. Celles-ci correspondent à nos coordonnées décrites ci-dessus. Nous utilisons ces coordonnées dans le bloc fn `mc_set_block` qui placera le bloc de votre choix aux coordonnées spécifiées. Pour placer quelque chose plus haut dans le ciel, il suffit d’augmenter la valeur y, et c’est pourquoi nous y ajoutons 5. Faisons-en une longue traînée :

    live_loop :melon_trail do
      x, y, z = mc_location
      mc_set_block :melon, x, y-1, z
      sleep 0.125
    end

Maintenant, passez à Minecraft, assurez-vous que vous êtes en mode vol (tapez deux fois sur Espace sinon) et volez autour du monde. Regardez derrière vous pour voir une jolie traînée de blocs de melon ! Voyez quelles sortes de motifs tortueux vous pouvez faire dans le ciel.

## Programmation interactive de Minecraft

Ceux d’entre vous qui ont suivi ce tutoriel au cours des derniers mois seront probablement bien étonnés ici. La chemin de melons est plutôt chouette, mais la partie la plus excitante de l’exemple précédent est que vous pouvez utiliser `live_loop` avec Minecraft ! Pour ceux qui ne savent pas, `live_loop` est la faculté magique spéciale de Sonic Pi qu’aucun autre langage de programmation ne possède. Elle vous permet d’exécuter plusieurs boucles en même temps et vous permet de les modifier pendant qu’elles s’exécutent. Elles sont incroyablement puissantes et formidablement amusantes. J’utilise des `live_loop` pour jouer de la musique dans les boîtes de nuit avec Sonic Pi - les DJ utilisent des disques et j’utilise des `live_loop` :-) Cependant, aujourd’hui, nous allons programmer de manière interactive la musique et Minecraft.

Commençons tout de suite. Exécutez le code ci-dessus et recommencez à faire votre chemin de melons. Maintenant, sans arrêter le code, changez simplement `:melon` en `:brick` et cliquez sur `Run`. Et voilà, vous construisez maintenant un chemin en briques. Comme c’est simple ! Envie d’un peu de musique pour l’accompagner ? Facile. Essayez ceci :

    live_loop :bass_trail do
      tick
      x, y, z = mc_location
      b = (ring :melon, :brick, :glass).look
      mc_set_block b, x, y -1, z
      note = (ring :e1, :e2, :e3).look
      use_synth :tb303
      play note, release: 0.1, cutoff: 70
      sleep 0.125
    end

Maintenant, pendant que ça joue, commencez à modifier le code. Changez les types de blocs - essayez `:water`, `:grass` ou votre type de bloc préféré. Essayez aussi de changer la valeur de coupure de `70` à `80` et puis jusqu’à `100`. C’est amusant, non ?

## Rassemblons tout

Combinons tout ce qu’on a vu jusqu’ici avec un peu plus de magie. Combinons notre capacité de téléportation avec le placement des blocs et la musique pour créer une vidéo musicale Minecraft. Ne vous inquiétez pas si vous ne comprenez pas tout, tapez simplement le code et jouez en modifiant certaines des valeurs en cours d’exécution. Amusez-vous bien et à la prochaine fois….

    live_loop :note_blocks do
      mc_message "This is Sonic Minecraft"
      with_fx :reverb do
        with_fx :echo, phase: 0.125, reps: 32 do
          tick
          x = (range 30, 90, step: 0.1).look
          y = 20
          z = -10
          mc_teleport x, y, z
          ns = (scale :e3, :minor_pentatonic)
          n = ns.shuffle.choose
          bs = (knit :glass, 3, :sand, 1)
          b = bs.look
          synth :beep, note: n, release: 0.1
          mc_set_block b, x+20, n-60+y, z+10
          mc_set_block b, x+20, n-60+y, z-10
          sleep 0.25
        end
      end
    end
    live_loop :beats do
      sample :bd_haus, cutoff: 100
      sleep 0.5
    end

# - Battements de Bizet

Après notre brève excursion dans le monde fantastique de la programmation Minecraft avec Sonic Pi le mois dernier, penchons-nous à nouveau sur la musique. Aujourd’hui nous allons amener un morceau classique de danse d’opéra droit dans le 21ème siècle en utilisant la puissance impressionnante du code.

## Scandaleux et Perturbateur

Sautons dans une machine à remonter le temps jusqu’en 1875. Un compositeur nommé Bizet avait juste terminé son dernier opéra : Carmen. Malheureusement comme beaucoup de nouveaux morceaux innovants et perturbateurs, les gens ne les aimaient pas du tout puisqu’ils les trouvaient trop choquants et différents. Malheureusement Bizet est mort dix ans avant que l’opéra ne connaisse un succès international et ne devienne l’un des opéras les plus connus et les plus fréquemment interprétés de tous les temps. Par sympathie pour cette tragédie, nous allons prendre un des thèmes principaux de Carmen et nous allons le convertir dans un format moderne de musique qui est aussi trop innovant et pertubateur pour la plupart des gens de notre époque : la musique codée interactive !

## La Habanera décryptée

Essayer de programmer un opéra entier de manière interactive serait un peu trop ambitieux pour ce tutoriel. Concentrons nous plutôt sur une des ses plus célèbres parties : la ligne de basse de la Habanera :

Cela peut vous sembler complètement illisible si vous n’avez pas étudié la notation musicale. Cependant, en tant que programmeurs nous voyons la notation musicale comme juste une autre forme de code, elle représente juste des instructions pour un musicien au lieu d’un ordinateur. C’est pourquoi nous devons trouver un moyen de la décoder.

## Notes

Les notes sont arrangées de gauche à droite comme les mots dans ce magazine mais elles ont aussi des hauteurs différentes. La position verticale en hauteur sur la partition représente la hauteur d’une note. Plus haute est la note sur la partition, plus la hauteur de la note est élevée.

Dans Sonic Pi nous savons déjà comment changer la hauteur d’une note : on peut utiliser des grands ou petits nombres comme `play 75` et `play 80` ou on peut utiliser les noms des notes : `play :E` et `play :F`. Heureusement chacune des positions verticales sur la partition représente un nom de note en particulier. Jetez un œil à cette table de correspondance bien pratique :

## Silences

Les partitions sont une sorte de code extrêmement riche et expressif capable de communiquer de nombreuses choses. Cela ne devrait donc pas nous surprendre que les partitions peuvent non seulement nous dire quelles notes jouer mais aussi quand ne pas jouer de note. En programmation c’est à peu près l’équivalent de l’idée de `nil` ou `null`: l’absence de valeur. En d’autres termes, ne pas jouer une note, c’est comme une absence de note.

Si vous regardez de près la partition, vous verrez que c’est en fait une combinaison de ronds noirs avec des barres qui représentent les notes à jouer et des choses ondulées qui représentent les silences. Heureusement, Sonic Pi a une notation très pratique pour un silence : `:r`, donc si on exécute `play :r` il jouera en fait un silence ! On pourrait aussi écrire `play :rest`, `play nil` ou `play false` qui sont autant de manières équivalentes de représenter un silence.

## Rythme

Enfin, il y a une dernière chose à apprendre à décoder dans la notation : la notion de durée des notes. Dans la notation originale vous verrez que les notes sont liées par des traits épais. La deuxième note a deux de ces traits ce qui veut dire qu’elle dure un 16ème de temps. Les autres notes ont un seul trait ce qui veut dire qu’elles durent un 8ème de temps. Le silence a aussi deux traits ondulés ce qui veut dire qu’il représente aussi un 16ème de temps.

Quand on essaie de décoder et d’explorer de nouvelles choses, un truc très pratique est de faire en sorte que tout se ressemble le plus possible pour essayer de voir des relations ou des modèles. Par exemple, lorsqu’on réécrit notre notation uniquement en double-croches, vous pouvez voir que notre notation se transforme en une belle séquence de notes et de silences.

## Recodage de la Habanera

Nous sommes maintenant prêt à commencer la traduction de cette ligne de basse en Sonic Pi. Encodons ces notes et silences dans un anneau :

    (ring :d, :r, :r, :a, :f5, :r, :a, :r)

Voyons comment ça sonne. Jetons ça dans une boucle interactive et parcourons-là :

    live_loop :habanera do
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end

Fabuleux, cette mélodie qu’on reconnaît immédiatement prend vie dans vos haut-parleurs. On a fait de gros efforts pour en arriver là, mais ça valait la peine, bien joué !

## Synthés grincheux

Maintenant qu’on a la ligne de basse, essayons de recréer une partie de l’ambiance de la scène d’opéra. Un synthé à essayer est `:blade` qui est un synthé style années 80. Essayons-le avec la note de départ `:d` passée dans un slicer et de la réverb :

    live_loop :habanera do
      use_synth :fm
      use_transpose -12
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end
    with_fx :reverb do
      live_loop :space_light do
        with_fx :slicer, phase: 0.25 do
          synth :blade, note: :d, release: 8, cutoff: 100, amp: 2
        end
        sleep 8
      end
    end

Maintenant essayez les autres notes de la ligne de basse : `:a` et `:f5`. Souvenez-vous que vous n’avez pas besoin de cliquer sur ‘Stop’, vous pouvez juste modifier le code pendant que la musique tourne et ensuite cliquer sur ‘Run’ à nouveau. Aussi essayez différentes valeurs pour l’option `phase:` du slicer comme `0.5`, `0.75` et `1`.

## Rassemblons tout

Enfin, combinons toutes les idées vues jusqu’ici dans un nouveau remix de la Habanera. Vous remarquerez peut-être que j’ai inclus une autre partie de la ligne de basse en commentaire. Quand vous aurez tout tapé dans un tampon de libre, cliquez sur ‘Run’ pour entendre la composition. Maintenant, sans cliquer sur ‘Stop’, décommentez la seconde ligne en enlevant le `#` et cliquez sur ‘Run’ à nouveau : c’est merveilleux, non ? Maintenant amusez-vous à le modifier vous-même.

    use_debug false
    bizet_bass = (ring :d, :r, :r, :a, :f5, :r, :a, :r)
    #bizet_bass = (ring :d, :r, :r, :Bb, :g5, :r, :Bb, :r)

    with_fx :reverb, room: 1, mix: 0.3 do
      live_loop :bizet do
        with_fx :slicer, phase: 0.125 do
          synth :blade, note: :d4, release: 8,
            cutoff: 100, amp: 1.5
        end
        16.times do
          tick
          play bizet_bass.look, release: 0.1
          play bizet_bass.look - 12, release: 0.3
          sleep 0.125
        end
      end
    end

    live_loop :ind do
      sample :loop_industrial, beat_stretch: 1,
        cutoff: 100, rate: 1
      sleep 1
    end

    live_loop :drums do
      sample :bd_haus, cutoff: 110
      synth :beep, note: 49, attack: 0,
        release: 0.1
      sleep 0.5
    end

# - Devenez un VJ Minecraft

Avertissement d’obsolescence Désolé mais cet article avait été réécrit quand l’Édition Minecraft Pi faisait encore partie du Système d’Exploitation Raspberry Pi et que Sonic Pi avait construit un support pour le contrôler avec du code. Malheureusement ce n’est plus le cas et le code spécifique à minecraft (les fonctions `mc_*`) n’est plus disponible dans Sonic Pi. Cependant, cet article est laissé ici comme un souvenir de ce qui était autrefois possible.

Tout le monde a joué à Minecraft. Vous aurez tous construit des structures incroyables, conçu des pièges rusés et même créé des lignes de chariots raffinées contrôlées par des interrupteurs de pierre rouge. Mais qui parmi vous a fait une performance vidéo avec Minecraft ? On parie que vous ne saviez pas que vous pouvez utiliser Minecraft pour créer des animations visuelles incroyables tout comme un VJ professionnel.

Si votre seule possibilité de modifier Minecraft était d’utiliser la souris, vous auriez du mal à changer les choses suffisamment vite. Heureusement pour vous,votre Raspberry Pi a une version de Minecraft qui peut être contrôlée avec du code. Il contient aussi une application nommée Sonic Pi qui rend la programmation Minecraft non seulement facile mais aussi incroyablement amusante.

Dans l’article d’aujourd’hui, nous allons vous montrer quelques trucs et astuces que nous avons utilisés pour créer des concerts, des performances dans des boîtes de nuit et salles de concert autour du monde.

Premiers pas…

## Commencer

Commençons avec un simple exercice d’échauffement pour nous rappeler les bases. Commencez par allumer votre Raspberry Pi et lancer Minecraft et Sonic Pi. Dans Minecraft, créez un nouveau monde, et dans Sonic Pi choisissez un tampon de libre et écrivez-y ce code :

    mc_message "Commençons..."

Cliquez sur le bouton ‘Run’ et vous verrez le message dans la fenêtre Minecraft. OK, on est prêt à démarrer, on va s’amuser…

## Tempêtes de sable

Quand on utilise Minecraft pour créer des visuels on essaie de penser à des choses qui auront l’air intéressantes et qui seront aussi faciles à générer avec du code. Un truc sympa est de créer une tempête de sable en laissant tomber des bloc de sable du ciel. Pour cela, on a juste besoin de quelques fonctions simples :

- `sleep`- pour insérer un délai entre des actions
- `mc_location`- pour trouver notre emplacement courant
- `mc_set_block`- pour positionner des blocs de sable à un endroit particulier
- `rrand`- pour nous permettre de générer des valeurs aléatoires dans un intervalle
- `live_loop`- pour nous permettre de faire pleuvoir du sable en continu

Si vous ne connaissez pas une des ces fonctions comme `rrand`, vous pouvez juste taper le mot dans votre tampon, cliquer dessus, puis taper `Control-i` sur le clavier pour ouvrir la documentation. Vous pouvez aussi aller dans l’onglet lang du système d’aide puis y chercher directement les fonctions et toutes sortes d’autres choses excitantes que vous pouvez faire.

Commençons par faire tomber un peu de pluie avant de laisser la tempête complète éclater. Récupérez votre emplacement courant et utilisez-la pour créer quelques blocs de sable dans le ciel pas loin :

    x, y, z = mc_location
    mc_set_block :sand, x, y + 20, z + 5
    sleep 2
    mc_set_block :sand, x, y + 20, z + 6
    sleep 2
    mc_set_block :sand, x, y + 20, z + 7
    sleep 2
    mc_set_block :sand, x, y + 20, z + 8

Après avoir cliqué sur ‘Run’, vous devrez peut-être un peu regarder autour de vous car les blocs peuvent commencer par tomber derrière vous, suivant dans quelle direction vous êtes pour le moment. N’ayez pas peur, si vous les avez ratés, cliquez à nouveau sur ‘Run’ pour créer encore un peu de pluie de sable, assurez-vous juste de regarder dans la bonne direction !

Parcourons rapidement ce qui se passe ici. Sur la première ligne nous avons récupéré l’emplacement Steve en coordonnées avec la fonction `mc_location` et les avons placées dans les variables `x`, `y` et `z`. Puis sur les lignes suivantes, nous avons utilisé la fonction `mc_set_block` pour placer un peu de sable aux mêmes coordonnées que Steve mais avec quelques modifications. On a utilisé la même coordonnée x, une coordonnée y 20 blocs plus haut et des coordonnées z successivement plus larges pour que le sable tombe dans une ligne en s’éloignant de Steve.

Et si vous preniez ce code et commenciez à jouer avec ? Essayez d’ajouter plus de lignes, de changer la durée d’attente, essayez de mélanger du `:sand` avec du `:gravel` et choisissez différentes coordonnées. Expérimentez et amusez-vous !

## Boucles interactives déchaînées

OK, il est l’heure de lancer la tempête en déchaînant la puissance complète de la `live_loop`- le pouvoir magique de Sonic Pi qui révèle la pleine puissance de la programmation interactive - changer le code à la volée pendant qu’il est en train de s’exécuter !

    live_loop :sand_storm do
      x, y, z = mc_location
      xd = rrand(-10, 10)
      zd = rrand(-10, 10)
      co = rrand(70, 130)
      synth :cnoise, attack: 0, release: 0.125, cutoff: co
      mc_set_block :sand, x + xd, y+20, z+zd
      sleep 0.125
    end

Qu’est-ce que c’est amusant ! On boucle assez vite (8 fois par seconde) et pendant chaque boucle, on trouve l’emplacement de Steve comme avant mais on génère ensuite trois valeurs aléatoires :

- `xd`: la différence pour x, qui sera entre -10 et 10
- `zd`: la différence pour z, aussi entre -10 et 10
- `co`: une valeur de coupure pour le filtre passe-bas, entre 70 et 130

On utilise ensuite ces valeurs aléatoires dans les fonctions `synth` et `mc_set_block` ce qui nous donne du sable qui tombe dans des endroits aléatoires autour de Steve ainsi qu’un son percussif semblable à de la pluie, joué le synthé `:cnoise`.

Pour ceux d’entre vous qui ne connaissaient pas les boucles interactives : c’est là qu’on commence vraiment à s’amuser avec Sonic Pi. Pendant que le code tourne et que le sable pleut, essayez de changer une des valeurs, peut-être la valeur d’attente à `0.25` ou le type de bloc `:sand` en `:gravel`. Ensuite cliquez sur ‘Run’ à nouveau. Et voilà ! Les choses changent sans que le code ne s’arrête. C’est le chemin pour vous produire comme un vrai VJ. Continuez à vous exercer à changer des choses. Jusqu’où arrivez-vous à modifier les visuels sans arrêter le code ?

## Des motifs de blocs épiques

Enfin une autre façon géniale de générer des visuels intéressants est de créer des énormes murs de motifs vers lesquels voler. Pour cet effet nous allons devoir passer d’un placement aléatoire de blocs à un placement de manière ordonnée. On peut faire cela en imbriquant deux itérations (cliquez sur le bouton ‘Aide’ et allez dans la section 5.2 du tutoriel “Itération et boucles” pour plus d’informations sur l’itération). L’étrange `|xd|` après le `do` veut dire que `xd` prendra une valeur à chaque boucle de l’itération. La première fois il vaudra `0`, puis `1`, puis `2`, etc. En imbriquant deux itérations comme cela on peut générer toutes les coordonnées d’un carré. On peut ensuite choisir aléatoirement des types de blocs d’un anneau de blocs pour obtenir un effet intéressant :

    x, y, z = mc_location
    bs = (ring :gold, :diamond, :glass)
    10.times do |xd|
      10.times do |yd|
        mc_set_block bs.choose, x + xd, y + yd, z
      end
    end

Pas mal. Puisqu’on s’amuse, essayez de changer `bs.choose` en `bs.tick` pour passer d’un motif aléatoire à un motif plus régulier. Essayez de changer les types de blocs et les plus aventureux parmi vous voudrons peut-être mettre ce code dans une `live_loop` pour que les modifs continuent à changer automatiquement.

Enfin, pour la fin du set du VJ, changez les deux `10.times` en `100.times` et cliquez sur ‘Run’. Boum ! Un énorme mur géant de briques aléatoires. Imaginez combien de temps ça vous aurait pris de construire ça avec votre souris ! Double-tapez la touche Espace pour entrer en mode volant et commencez à planer pour obtenir de super effets visuels. Ne vous arrêtez pas là, utilisez votre imagination pour trouver des idées sympa et utilisez ensuite la puissance de programmation de Sonic Pi pour le réaliser. Quand vous vous serez suffisamment exercés, baissez la lumière et donnez un spectacle de VJ pour vos amis !

# - Surfer sur des flux aléatoires

Dans le quatrième épisode de cette série de tutoriels, nous avons brièvement jeté un œil à l’aléation en codant des riffs grésillants de synthé. Vu comme l’aléation est une partie très importante de mes performances de DJ codeur en live, j’ai pensé qu’il serait utile d’en couvrir les bases plus en détail. Mettez votre casquette et surfons sur des flux aléatoires !

## Il n’y a pas d’aléation

La première chose à savoir et qui pourrait vraiment vous surprendre en jouant avec les fonctions aléatoires de Sonic Pi, c’est qu’elles ne sont en fait pas vraiment aléatoires. Qu’est-ce que cela signifie ? Eh bien, faisons quelques essais. Commencez par imaginer un nombre dans votre tête entre 0 et 1. Gardez-le en tête et ne me le dîtes pas. Maintenant, laissez-moi deviner… est-ce que c’était `0.321567` ? Non ? Bah, je ne suis clairement pas bon à ce jeu. Essayons encore une fois, mais demandons à Sonic Pi de choisir un nombre cette fois. Lancez Sonic Pi version 2.7 ou plus et demandez lui un nombre aléatoire mais de nouveau ne me dites pas le résultat :

    print rand

Et maintenant pour le truc… est-ce que c’était `0.75006103515625` ? Oui ! Ha, je vois que vous êtes un peu sceptique. C’était peut-être juste de la chance. Essayons encore. Cliquez sur ‘Run’ à nouveau et regardons ce qu’on obtient… Quoi ? Encore `0.75006103515625` ? Ca ne peut clairement pas être aléatoire ! Vous avez raison, ça ne l’est pas.

Qu’est-ce qui se passe ? En informatique, on appelle cela le déterminisme. Cela veut juste dire que rien n’a lieu par hasard et que tout a sa destinée. Votre version de Sonic Pi a le destin de toujours retourner `0.75006103515625` dans le programme ci-dessus. Cela peut sembler plutôt inutile, mais laissez-moi vous assurer, c’est une des parties les plus puissantes de Sonic Pi. Si vous persévérez, vous apprendrez comment compter sur la nature déterministe de Sonic Pi en ce qui concerne l’aléatoire et vous vous en servirez comme fondation dans vos compositions et performances de live coding.

## Une mélodie aléatoire

Quand Sonic Pi démarre, il charge en fait en mémoire une séquence de 441 000 valeurs aléatoires pré-générées. Quand vous appelez une fonction aléatoire comme `rand` ou `rrand`, ce flux aléatoire est utilisé pour générer votre résultat. Chaque appel à une fonction aléatoire consomme une valeur de ce flux. Ainsi le dixième appel à une fonction aléatoire utilisera la dixième valeur du flux. Aussi, chaque fois que vous cliquez sur le bouton ‘Run’, le flux est réinitialisé pour cette exécution. C’est pour cela que j’ai pu prédire le résultat de `rand` et pourquoi la mélodie ‘aléatoire’ était la même à chaque fois. La version de Sonic Pi de chacun utilise exactement le même flux aléatoire ce qui est très important quand on commence à partager nos morceaux.

Utilisons cette connaissance pour générer une mélodie aléatoire répétable :

    8.times do
     play rrand_i(50, 95)
     sleep 0.125
    end

Tapez ceci dans un tampon étant libre et cliquez sur ‘Run’. Vous entendrez une mélodie de notes ‘aléatoires’ entre 50 et 95. Quand elle aura fini, cliquez sur ‘Run’ à nouveau pour entendre exactement la même mélodie à nouveau.

## Des fonctions d’aléation pratiques

Sonic Pi contient un certain nombre de fonctions utiles pour travailler avec le flux aléatoire. Voici une liste de certaines des plus utiles :

- `rand`: retourne simplement la prochaine valeur dans le flux aléatoire
- `rrand`: retourne une valeur aléatoire dans un intervalle
- `rrand_i`: retourne une valeur entière aléatoire dans un intervalle
- `one_in`: retourne vrai ou faux pour une probabilité donnée
- `dice`: imite un jet de dé et retourne une valeur entre 1 et 6
- `choose`: choisit une valeur aléatoire dans une liste

Regardez leur documentation dans le système d’aide pour des informations détaillées et des exemples.

## Réinitialiser le flux

Même si la capacité de répéter une séquence de notes choisies est essentielle pour vous permettre de rejouer une mélodie sur la piste de danse, ça pourrait ne pas être exactement la mélodie que vous souhaitez. Ne serait-ce pas génial si on pouvait essayez différentes mélodies et choisir celle qu’on préfère ? C’est ici que la vraie magie commence.

On peut régler le flux manuellement avec la fonction `use_random_seed`. En informatique, une graine aléatoire est le point de départ à partir duquel un nouveau flux de valeurs aléatoires peut fleurir. Essayons-le :

    use_random_seed 0
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

Super, on récupère les trois premières notes de notre mélodie aléatoire ci-dessus : `84`, `83` et `71`. Cependant on peut maintenant changer la graine. Par exemple :

    use_random_seed 1
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

Intéressant, on obtient `83`, `71` et `61`. Vous avez peut-être remarqué que les deux premiers nombres ici sont les mêmes que les deux derniers nombres d’avant : ce n’est pas une coïncidence.

Rappelez-vous que le flux aléatoire est juste une liste géante de valeurs pré-choisies. Choisir une graine aléatoire nous déplace juste en un point de la liste. Une autre manière de voir ça est d’imaginer un énorme jeu de cartes pré-mélangées. Utiliser une graine aléatoire, c’est couper le jeu en un point particulier. Ce qui est fabuleux avec ça c’est qu’on peut se déplacer dans le flux aléatoire, ce qui nous donne un énorme pouvoir quand on fait de la musique.

Revisitons notre mélodie aléatoire de huit notes avec cette nouvelle capacité de réinitialiser le flux, et mettons là dans une boucle interactive pour pouvoir expérimenter pendant qu’elle joue :

    live_loop :random_riff do
      use_random_seed 0
      8.times do
        play rrand_i(50, 95), release: 0.1
        sleep 0.125
      end
    end

Maintenant, pendant qu’elle est en train de jouer, changez la valeur de la graine de `0` en quelque chose d’autre. Essayez `100`, ou pourquoi pas `999`. Essayez vos propres valeurs, expérimentez et amusez-vous : voyez quelle graine génère la mélodie que vous préférez.

## Rassemblons tout

Le tutoriel de ce mois a été un plongeon bien technique dans les entrailles de la fonctionnalité aléatoire de Sonic Pi. J’espère que cela vous a montré un peu comment elle marche et comment vous pouvez commencer à utiliser de l’aléatoire de manière fiable pour créer des motifs reproductibles dans votre musique. Il est important de souligner qu’on peut utiliser de l’aléatoire reproductible où on veut. Par exemple, on peut rendre aléatoire l’amplitude des notes, le mix d’un effet, etc. Dans l’avenir nous regarderons de plus près certaines de ces applications, mais pour le moment je vais vous laisser avec un exemple court.

Tapez le code suivant dans un buffer disponible, cliquez sur ‘Run’ et commencez à modifier les graines, cliquez sur ‘Run’ de nouveau (pendant que le code tourne) et explorez les différents sons, rythmes et mélodies que vous pouvez créer. Quand vous en trouvez une qui sonne bien, notez la graine pour pouvoir y revenir plus tard. Enfin, quand vous aurez trouvé quelques graines qui vous plaisent, donnez un concert de live coding à vos amis en changeant simplement entre vos graines préférées pour créer un morceau entier.

    live_loop :random_riff do
      use_random_seed 10300
      use_synth :prophet
      s = [0.125, 0.25, 0.5].choose
      8.times do
        r = [0.125, 0.25, 1, 2].choose
        n = (scale :e3, :minor).choose
        co = rrand(30, 100)
        play n, release: r, cutoff: co
        sleep s
      end
    end
    live_loop :drums do
      use_random_seed 2001
      16.times do
        r = rrand(0.5, 10)
        sample :drum_bass_hard, rate: r, amp: rand
        sleep 0.125
      end
    end

# - Contrôler votre son

Jusqu’ici dans cette série nous nous sommes concentrés sur le déclenchement de sons. Nous avons découvert qu’on pouvait déclencher les nombreux synthés présents dans Sonic Pi avec `play` ou `synth` et comment déclencher des samples pré-enregistrés avec `sample`. Nous avons aussi vu comment on pouvait entourer ces sons dans des effets studio tels que la reverb et la distorsion en utilisant la commande `with_fx`. En combinant cela avec le système de chronométrage incroyablement précis de Sonic Pi on peut produire un vaste ensemble de sons, rythmes et mélodies. Cependant, une fois qu’on a soigneusement sélectionné les options d’un son en particulier et qu’on l’a déclenché, on ne peut plus le modifier pendant qu’il est joué, c’est ça ? Non ! Aujourd’hui vous allez apprendre quelque chose de très puissant : comment contrôler des synthés qui sont en train d’être joués.

## Un son de base

Créons un simple son agréable. Lancez Sonic Pi et tapez le code suivant dans un buffer disponible :

    synth :prophet, note: :e1, release: 8, cutoff: 100

Maintenant cliquez sur le bouton ‘Run’ en haut à gauche pour entendre un beau son de synthé grondant. Allez-y, cliquez à nouveau dessus quelques fois pour vous habituer. OK, fini ? Commençons à le contrôler !

## Nœuds de synthé

Une fonctionnalité peu connue de Sonic Pi est que les fonctions `play`, `synth` et `sample` retournent ce qu’on appelle un `SynthNode` qui représente un son en train d’être joué. Vous pouvez capturer un de ces `SynthNode`s en utilisant une variable standard et le contrôler ensuite dans le futur. Par exemple, changeons la valeur de l’option `cutoff:` après un battement :

    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    control sn, cutoff: 130

Regardons chaque ligne une par une :

On commence par déclencher le synthé `:prophet` en utilisant la fonction `synth` habituelle. Cependant on capture aussi le résultat dans une variable nommée `sn`. On aurait pu appeler cette variable complètement différemment comme par exemple `synth_node` ou `jane` : le nom n’a pas d’importance. Enfin il est important de choisir un nom qui a du sens pour vous pour vos performances et pour les gens qui lisent votre code. J’ai choisi `sn` parce que c’est un bon petit moyen mnémotechnique pour ‘synth node’.

A la ligne 2 on a une commande `sleep` standard. Ca ne fait rien de spécial : ça demande juste à l’ordinateur d’attendre un battement, un temps, avant de passer à la ligne suivante.

C’est à la ligne 3 qu’on commence à s’amuser. Ici on utilise la fonction `control` pour dire à notre `SynthNode` courant de changer la valeur de coupure en `130`. Si vous cliquez sur le bouton ‘Run’, vous entendrez le synthé `:prophet` commencer à jouer comme avant, mais après un battement il changera et sonnera beaucoup plus clair.

Options modulables

La plupart des options des synthés et des effets inclus dans Sonic Pi peuvent être modifiés après avoir été déclenchés. Cependant, ce n’est pas le cas pour tous. Par exemple, les options d’enveloppe `attack:`, `decay:`, `sustain:` et `release:` ne peuvent être définies que quand on déclenche le synthé. Pour savoir quelles options peuvent être modifiées ou non, c’est simple : allez voir la documentation d’un synthé ou effet et regardez la documentation des options individuelles et cherchez les phrases “May be changed whilst playing” (Peut être modifiée en jouant) ou “Can not be changed once set” (ne peut pas être modifiée une fois définie). Par exemple, la documentation de l’option `attack:` du synthé `:beep` indique clairement qu’on ne peut pas la modifier ultérieurement :

- Valeur par défaut : 0
- Doit être supérieur ou égal à 0
- Ne peut pas être modifiée après sa définition
- Mise à l’échelle avec la valeur courante de BPM

## Modifications multiples

Pendant qu’un synthé est joué vous n’êtes pas limité à ne le changer qu’une fois : vous êtes libre de le modifier autant que vous le souhaitez. Par exemple, on peut transformer notre `:prophet` en petit arpégiateur avec le code suivant :

    notes = (scale :e3, :minor_pentatonic)
    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    16.times do
      control sn, note: notes.tick
      sleep 0.125
    end

Dans cet extrait de code, nous avons juste ajouté des petites choses en plus. On commence par définir une nouvelle variable appelée `notes` qui contient les notes qu’on aimerait parcourir en boucle (un arpégiateur est juste un mot savant pour quelque chose qui parcourt en boucle une liste de notes dans un ordre donné). Ensuite on déplace notre appel à `control` dans une itération en l’appelant 16 fois. A chaque appel à `control`, on parcourt notre anneau de `notes` qui va se répéter automatiquement quand on arrivera à sa fin (grâce à la puissance fabuleuse des anneaux de Sonic Pi). Pour varier un peu, essayez de remplacer `.tick` par `.choose` et tentez d’entendre la différence.

Notez qu’on peut modifier plusieurs options en même temps. Essayez de changer la ligne de contrôle en la suivante et écoutez la différence :

    control sn, note: notes.tick, cutoff: rrand(70, 130)

## Transitions

Quand on contrôle un `SynthNode`, il répond exactement à ce moment-là et change immédiatement la valeur de l’option comme si vous aviez pressé un bouton ou actionné un interrupteur pour demander la modification. Cela peut sonner rythmique et percussif, notamment si l’option contrôle un aspect du timbre comme `cutoff:`. Cependant, on n’a pas toujours envie que la modification arrive immédiatement. On a parfois envie de se déplacer en douceur de la valeur courante à la nouvelle, comme si on avait déplacé un curseur. Bien sûr, Sonic Pi sait aussi faire cela en utilisant les options `_slide:`.

Chaque option qui peut être modifiée a aussi une option spéciale correspondante `_slide:` qui vous permet de définir un temps de transition. Par exemple, `amp:` a `amp_slide:` et `cutoff:` a `cutoff_slide:`. Ces options de transition marchent un peu différemment de toutes les autres options parce qu’elles disent à la note de synthé comment se comporter la prochaine fois qu’elle seront contrôlées. Voyons ça :

    sn = synth :prophet, note: :e1, release: 8, cutoff: 70, cutoff_slide: 2
    sleep 1
    control sn, cutoff: 130

Remarquez que cet exemple est exactement le même qu’avant sauf qu’on a ajouté `cutoff_slide:`. Ceci indique que la prochaine fois que l’option `cutoff:` de ce synthé sera contrôlée, il mettra deux battements pour passer de sa valeur courante à la nouvelle valeur. Par conséquent, quand on utilise `control` vous pouvez entendre la coupure changer graduellement de 70 à 130. Cela crée une sensation dynamique intéressante pour le son. Maintenant essayez de changer la durée de `cutoff_slide:` en une valeur plus courte comme 0.5 ou une valeur plus longue comme 4 pour voir comment ça change le son. Souvenez-vous que vous pouvez effectuer une transition pour chacune des options modifiables de cette même manière, et chaque valeur de `_slide:` peut être complètement différente donc vous pouvez avoir une transition lente de la coupure, une transition rapide de l’amplitude, et une transition de la stéréo un peu entre les deux si c’est ce que vous avez envie de créer.

## Rassemblons tout

Regardons un court exemple qui montre la puissance du contrôle des synthés après leur déclenchement. Remarquez que vous pouvez aussi effectuer des transitions sur les effets, comme vous l’avez fait avec les synthés mais avec une syntaxe légèrement différente. Regardez la section 7.2 du tutoriel inclus dans Sonic Pi pour plus d’informations sur le contrôle des effets.

Copiez le code dans un tampon de libre et écoutez. Ne vous arrêtez pas là : jouez à modifier le code. Changez les durées de transition, changez les notes, le synthé, l’effet et les durées d’attente et voyez si vous pouvez le transformer en quelque chose de complètement différent !

    live_loop :moon_rise do
      with_fx :echo, mix: 0, mix_slide: 8 do |fx|
        control fx, mix: 1
        notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle
        sn = synth :prophet , sustain: 8, note: :e1, cutoff: 70, cutoff_slide: 8
        control sn, cutoff: 130
        sleep 2
        32.times do
          control sn, note: notes.tick, pan: rrand(-1, 1)
          sleep 0.125
        end
      end
    end

# - Suivre le rythme

Le mois dernier dans cette série nous avons regardé en détail comment fonctionne le système de gestion de l’aléatoire de Sonic Pi. On a exploré comment on peut l’utiliser de manière déterministe pour avoir de nouveaux niveaux de contrôle dynamique sur notre code. Ce mois-ci nous allons continuer notre exploration technique et regarder le système unique de ‘tick’ de Sonic Pi. A la fin de cet article, vous saurez parcourir les rythmes et les mélodies à votre manière et devenir à votre façon DJ en live coding.

## Comptage du temps

Quand on fait de la musique on a souvent envie de faire quelque chose de différent en fonction du temps sur lequel on est. Sonic Pi a un système spécial pour compter les temps appelé `tick` pour vous donner un contrôle précis sur quand est-ce qu’un battement arrive réellement et il supporte même des battements multiples avec leur propre tempo.

Amusons-nous : pour avancer le temps on a juste besoin d’appeler `tick`. Ouvrez un tampon libre, tapez le code suivant et cliquez sur le bouton ‘Run’ :

    puts tick #=> 0

Cela retournera le battement courant : `0`. Remarquez que même si vous cliquez plusieurs fois sur le bouton ‘Run’, il retournera toujours `0`. Cela parce que chaque exécution commence avec un compteur qui part de 0. Cependant, pendant que le programme tourne, on peut avancer le compteur autant qu’on veut :

    puts tick #=> 0
    puts tick #=> 1
    puts tick #=> 2

Quand vous voyez le symbole `#=>` à la fin d’une ligne de code cela veut dire que cette ligne va noter ce texte dans la partie de droite de Sonic Pi. Par exemple, `puts foo #=> 0` veut dire que le code `puts foo` affiche `0` dans le log à cet endroit du programme.

## Vérification du rythme

On a vu que `tick` fait deux choses. Il incrémente (ajoute un) et retourne le compteur courant. Parfois on veut juste connaître la valeur du compteur courant sans l’incrémenter et on peut faire cela avec `look` :

    puts tick #=> 0
    puts tick #=> 1
    puts look #=> 1
    puts look #=> 1

Dans ce code on incrémente le compteur deux fois puis on appelle `look` deux fois. On verra les valeurs suivantes dans le log : `0`, `1`, `1`, `1`. Les deux premiers `tick`s ont retourné `0` et `1`, comme attendu, puis les deux `look`s ont juste retourné la dernière valeur du compteur deux fois, donc `1`.

## Anneaux

On peut donc avancer le compteur avec `tick` et en connaître la valeur avec `look`. Qu’est-ce qui vient ensuite ? On a besoin de quelque chose à parcourir. Sonic Pi utilise les anneaux pour représenter les mélodies et les rythmes ; le système de tick a été conçu spécialement pour fonctionner avec eux ! En fait, les anneaux ont leur propre version de `tick` qui fait deux choses. D’un côté, elle agit comme un tick normal et incrémente le compteur. De l’autre, elle donne une valeur de l’anneau en utilisant le compteur comme index. Voyons cela :

    puts (ring :a, :b, :c).tick #=> :a

`.tick` est une version spéciale avec un point de `tick` qui nous retourne la première valeur de l’anneau : `:a`. On peut récupérer chacune des notes de l’anneau en appelant `:tick` plusieurs fois :

    puts (ring :a, :b, :c).tick #=> :a
    puts (ring :a, :b, :c).tick #=> :b
    puts (ring :a, :b, :c).tick #=> :c
    puts (ring :a, :b, :c).tick #=> :a
    puts look                   #=> 3

Regardez le log et vous verrez `:a`, `:b`, `:c` et puis de nouveau `:a`. Remarquez que `look` retourne `3`. Les appels à `.tick` se comportent comme les appels à `tick` : ils incrémentent le compteur local.

## Un arpégiateur dans une boucle interactive

La véritable puissance vient quand on mélange `tick` avec des anneaux et des `live_loop`s. En les combinant on a tous les outils dont on a besoin pour construire et comprendre un arpégiateur simple. On a juste besoin de quatre choses :

1. Une boucle contenant les notes que l’on veut boucler.
2. Une manière d’incrémenter et de lire le rythme.
3. La possibilité de jouer une note basée sur le rythme actuel.
4. Une structure en boucle pour que l’arpégiateur se répète.

Ces concepts se retrouvent tous dans le code suivant :

    notes = (ring 57, 62, 55, 59, 64)
    live_loop :arp do
      use_synth :dpulse
      play notes.tick, release: 0.2
      sleep 0.125
    end

Regardons chacune de ces lignes. On commence par définir notre anneau de notes que nous allons jouer en continu. On crée ensuite une `live_loop` nommée `:arp` qui va boucler pour nous. A chaque itération de la `live_loop` on choisit un synthé `:dpulse` et on joue ensuite la note suivante de notre anneau en utilisant `.tick`. Souvenez-vous que cela va incrémenter notre compteur de temps et en utiliser la valeur comme index dans notre anneau de notes. Enfin on attend un huitième de temps avant de recommencer la boucle.

## Rythmes multiples simultanés

Une chose très importante à savoir est que les `tick`s sont liés à la `live_loop`. Cela veut dire que chaque `live_loop` a son propre compteur indépendant. C’est beaucoup plus puissant que d’avoir un métronome et battement global. Regardons ce que cela donne :

    notes = (ring 57, 62, 55, 59, 64)
    with_fx :reverb do
      live_loop :arp do
        use_synth :dpulse
        play notes.tick + 12, release: 0.1
        sleep 0.125
      end
    end
    live_loop :arp2 do
      use_synth :dsaw
      play notes.tick - 12, release: 0.2
      sleep 0.75
    end

## Collisions de rythmes

Une grande source de confusion dans le système de tick de Sonic Pi est quand on veut parcourir plusieurs anneaux dans le même `live_loop` :

    use_bpm 300
    use_synth :blade
    live_loop :foo do
      play (ring :e1, :e2, :e3).tick
      play (scale :e3, :minor_pentatonic).tick
      sleep 1
    end

Même si chaque `live_loop` a son compteur indépendant, ici on appelle `.tick` deux fois dans la même `live_loop`. Cela veut dire que le compteur sera incrémenté deux fois à chaque boucle. Cela peut produire de la polyrythmie intéressante mais ce n’est pas souvent ce que l’on souhaite. Il y a deux solutions à ce problème. Une option est d’appeler `tick` manuellement au début de la `live_loop` puis d’utiliser `look` pour chercher la valeur courante du compteur dans chaque `live_loop`. La seconde solution est de passer un nom unique à chaque appel à `.tick`, comme par exemple `.tick(:foo)`. Sonic Pi créera alors un compteur séparé pour chaque tick nommé que vous utiliserez. Ainsi on peut travailler avec autant de compteurs que nécessaire ! Lisez le section 9.4 sur les ticks nommés dans le tutoriel inclus dans Sonic Pi pour plus d’informations.

## Rassemblons tout

Combinons nos connaissances sur les `tick`s, `ring`s (anneaux) et `live_loop`s pour un dernier exemple amusant. Comme d’habitude, ne prenez pas ça pour un morceau terminé. Commencez à changer des choses et amusez-vous avec et voyez en quoi vous pouvez le transformer. A la prochaine…

    use_bpm 240
    notes = (scale :e3, :minor_pentatonic).shuffle
    live_loop :foo do
      use_synth :blade
      with_fx :reverb, reps: 8, room: 1 do
        tick
        co = (line 70, 130, steps: 32).tick(:cutoff)
        play (octs :e3, 3).look, cutoff: co, amp: 2
        play notes.look, amp: 4
        sleep 1
      end
    end
    live_loop :bar do
      tick
      sample :bd_ada if (spread 1, 4).look
      use_synth :tb303
      co = (line 70, 130, steps: 16).look
      r = (line 0.1, 0.5, steps: 64).mirror.look
      play notes.look, release: r, cutoff: co
      sleep 0.5
    end

# - Tranchage d’échantillon

Dans l’épisode 3 de cette série sur Sonic Pi, nous avons regardé comment boucler, étirer et filtrer un des breaks de batterie les plus connus de tous les temps - l’Amen Break. Dans ce tutoriel, nous allons faire un pas de plus et apprendre comment le découper, mélanger les bouts et les recoller ensemble dans un agencement complètement nouveau. Si cela vous paraît un peu fou, ne vous inquiétez pas, tout va s’éclaircir et vous maîtriserez bientôt un nouvel outil puissant pour vos sessions de Live Coding.

## Le son en tant que données

Avant de démarrer, prenons juste un petit moment pour comprendre comment travailler avec les échantillons. Maintenant, vous devriez tous avoir manipulé le puissant échantillonneur de Sonic Pi. Si ce n’est pas le cas, c’est le moment ! Démarrez votre Raspberry Pi, lancez Sonic Pi depuis le menu Programmation, tapez ce qui suit dans un tampon vide et appuyez sur le bouton Run pour entendre un rythme de batterie préenregistré :

    sample :loop_amen

L’enregistrement d’un son est simplement représenté comme de la donnée - un tas de nombres entre -1 et 1 qui représentent les pics et creux de l’onde sonore. Si nous rejouons ces nombres dans l’ordre, nous obtenons le son original. Cependant, qu’est-ce qui nous empêche de les jouer dans un ordre différent pour créer un nouveau son ?

Comment sont réellement enregistrés les échantillons ? C’est en fait assez simple une fois que vous comprenez les bases physiques du son. Quand vous produisez un son - par exemple en frappant sur une batterie, le bruit voyage dans l’air d’une façon proche de celle des petites ondes dans un lac quand vous y jetez un caillou. Quand ces ondes atteignent vos oreilles, votre tympan bouge de façon synchrone et convertit ces mouvements en son que vous entendez. Si nous souhaitons enregistrer et rejouer le son, nous avons donc besoin d’un moyen de capturer, stocker et reproduire ces ondes. Une des méthodes est d’utiliser un microphone qui se comporte comme un tympan et effectue un va-et-vient lorsque les ondes sonores le touchent. Le microphone convertit ensuite sa position en un petit signal électrique qui est ensuite mesuré de nombreuses fois par seconde. Ces mesures sont ensuite représentées par une série de nombres compris entre -1 et 1.

Si nous devions tracer point par point une représentation visuelle du son, ce serait un simple graphique de données avec le temps sur l’axe x et la position du microphone/de l’enceinte comme une valeur entre -1 et 1 sur l’axe y. Vous pouvez voir un exemple d’un tel graphique en haut du diagramme.

## Jouer une partie d’un échantillon

Donc, comment coder dans Sonic Pi la lecture d’un échantillon dans un ordre différent ? Pour répondre à cette question, nous devons jeter un oeil sur les options `start:` et `finish:` de `sample`. Celles-ci nous permettent de contrôler les position de début et de fin de notre lecture des nombres qui représentent le son. Les valeurs de ces deux options sont représentées par un nombre entre `0` et `1` où `0` représente le début de l’échantillon et `1` en est la fin. Donc, pour jouer la première partie de l’Amen Break, nous devons simplement spécifier un `finish:` à `0.5` :

    sample :loop_amen, finish: 0.5

Nous pouvons ajouter une valeur `start:` pour jouer une partie encore plus petite de l’échantillon :

    sample :loop_amen, start: 0.25, finish: 0.5

Pour le plaisir, vous pouvez même avoir la valeur `finish:` inférieure à la valeur `start:` et il jouera la section à l’envers :

    sample :loop_amen, start: 0.5, finish: 0.25

## Réordonner la lecture des échantillons

Maintenant que nous savons d’une part qu’un échantillon est simplement une liste de nombres qui peuvent être joués dans n’importe quel ordre et que d’autre part, nous savons comment jouer une partie spécifique d’un échantillon, nous pouvons désormais nous amuser à jouer un échantillon dans le ‘mauvais’ ordre.

Prenons notre Amen Break et découpons-le en 8 tranches égales et mélangeons ensuite les morceaux. Regardez le diagramme : en haut A) représente le graphe des données originales de l’échantillon. Le découper en 8 tranches nous donne B) - notez que nous avons donné à chaque tranche une couleur différente pour aider à les distinguer. Vous pouvez voir les valeurs de début (`start`) et de fin (`finish`) en haut. Enfin C) est une réorganisation des tranches. Nous pouvons ensuite jouer ceci pour créer un nouveau rythme. Jetez un coup d’œil sur le code utilisé pour faire cela :

    live_loop :beat_slicer do
      slice_idx = rand_i(8)
      slice_size = 0.125
      s = slice_idx * slice_size
      f = s + slice_size
      sample :loop_amen, start: s, finish: f
      sleep sample_duration :loop_amen, start: s, finish: f
    end

1. Nous choisissons une tranche aléatoire à jouer, qui doit être un nombre aléatoire entre 0 et 7 (souvenez-vous que nous commençons à compter à partir de 0). Sonic Pi a une fonction pratique pour faire exactement cela : `rand_i(8)`. Nous stockons ensuite l’index de cette tranche aléatoire dans la variable `slice_idx`.
2. Nous définissons la taille notre tranche, `slice_size` à 1/8 soit 0.125. `slice_size` nous est nécessaire pour convertir l’index `slice_idx` en une valeur comprise entre 0 et 1 pour l’utiliser dans l’option `start:`.
3. Nous calculons la position de départ `s` en multipliant l’index `slice_idx` par la taille de la tranche `slice_size`.
4. Nous pouvons calculer la position finale de ‘f’ en ajoutant la ‘slice_size’ à la position de départ ‘s’.
5. Nous pouvons maintenant jouer la tranche d’échantillon en associant les valeurs `s` et `f` aux options `start:` et `finish:` de `sample`.
6. Avant de jouer la prochaine tranche, nous devons savoir pendant combien de temps faire une pause avec `sleep`, ce qui doit correspondre à la durée de la tranche d’échantillon. Heureusement, Sonic Pi s’en occupe avec la fonction `sample_duration`, qui accepte les mêmes options que `sample` et retourne simplement la durée. Par conséquent, en fournissant à `sample_duration` nos options `start:` et `finish:`, nous pouvons trouver la durée d’une tranche.
7. Nous enveloppons tout ce code dans une boucle `live_loop` pour que nous puissions continuer à choisir de nouvelles tranches à jouer.

## Rassemblons tout

Combinons tout ce que nous avons vu jusqu’à maintenant dans un dernier exemple, qui démontre comment nous pouvons utiliser une approche similaire pour combiner aléatoirement des morceaux de rythmes avec de la basse pour créer le début d’une piste intéressante. Maintenant c’est votre tour - prenez le code suivant comme point de départ et voyez si vous pouvez le modifier à votre façon pour créer quelque chose de nouveau…

    live_loop :sliced_amen do
      n = 8
      s =  line(0, 1, steps: n).choose
      f = s + (1.0 / n)
      sample :loop_amen, beat_stretch: 2, start: s, finish: f
      sleep 2.0  / n
    end
    live_loop :acid_bass do
      with_fx :reverb, room: 1, reps: 32, amp: 0.6 do
        tick
        n = (octs :e0, 3).look - (knit 0, 3 * 8, -4, 3 * 8).look
        co = rrand(70, 110)
        synth :beep, note: n + 36, release: 0.1, wave: 0, cutoff: co
        synth :tb303, note: n, release: 0.2, wave: 0, cutoff: co
        sleep (ring 0.125, 0.25).look
      end
    end

# - Coder un séquenceur probabiliste

Dans les épisodes précédents de cette série sur Sonic PI, nous avons exploré la puissance de l’aléatoire pour introduire de la variété, de la surprise et du changement dans nos pistes et nos représentations de Live Coding. Par exemple, nous avons choisi aléatoirement des notes d’une gamme pour créer des mélodies sans fin. Aujourd’hui, nous allons apprendre une nouvelle technique qui utilise l’aléatoire pour le rythme - les rythmes probabilistes !

## Probabilité

Avant de pouvoir commencer à faire de nouveaux rythmes et des rythmes de synthé, nous devons faire un plongeon rapide dans les bases de la probabilité. Cela peut sembler intimidant et compliqué, mais vraiment c’est aussi simple que de lancer un dé - honnêtement ! Lorsque vous prenez un dé régulier à 6 faces d’un jeu de société et le lancez, que se passe-t’il réellement ? Eh bien, tout d’abord, vous allez tomber sur 1, 2, 3, 4, 5 ou 6 avec exactement la même chance d’obtenir l’un des numéros. En fait, étant donné que c’est un dé à 6 côtés, en moyenne (si vous lancez de nombreuses fois), vous allez tomber sur un 1 tous les 6 lancers. Cela signifie que vous avez une chance sur 6 de lancer un 1. Nous pouvons émuler le lancement de dés dans Sonic Pi avec le fn ‘dice’. Jetons-en un 8 fois :

    8.times do
      puts dice
      sleep 1
    end

Remarquez comme le journal affiche des valeurs entre 1 et 6 comme si nous avions lancé nous-même un dé.

## Rythmes aléatoires

Maintenant, imaginez vous avez un tambour et chaque fois que vous êtes sur le point de le frapper, vous lancez un dé. Si vous tirez un 1, vous frappez le tambour sinon, autre valeur que 1, vous ne frappez pas. Vous avez maintenant une boîte à rythmes probabiliste qui fonctionne avec une probabilité de 1/6 ! Écoutons à quoi ça ressemble :

    live_loop :random_beat do
      sample :drum_snare_hard if dice == 1
      sleep 0.125
    end

Passons en revue rapidement chaque ligne pour nous assurer que tout est parfaitement clair. Tout d’abord, nous créons une nouvelle `live_loop` appelée `:random_beat` qui va continuellement répéter les deux lignes entre `do` et `end`. La première de ces lignes est un appel à `sample` qui jouera un son préenregistré (le son `:drum_snare_hard` dans ce cas). Cependant, cette ligne a une fin conditionnelle spéciale `if`. Cela signifie que la ligne ne sera exécutée que si la déclaration située à droite du `if` («si») est `true` («vraie»). Dans ce cas, la déclaration est `dice == 1`. C’est ce qu’on appelle notre fonction `dice` qui, comme nous l’avons vu, renvoie une valeur comprise entre 1 et 6. Nous utilisons ensuite l’opérateur d’égalité `==` pour vérifier si cette valeur est `1`. Si c’est `1`, alors le test d’égalité est vrai, `true`, et notre caisse claire sonne. Si ce n’est pas `1` alors le test d’égalité n’est pas vérifié, il est faux, `false`, et la caisse claire est ignorée. La deuxième ligne attend simplement `0.125` secondes avant de lancer à nouveau les dés.

## Changer les probabilités

Ceux d’entre vous qui ont joué des jeux de rôle seront familiers avec beaucoup de dés de forme étrange avec différentes étendues de numéros. Par exemple, il y a le dé en tétraèdre qui a 4 côtés ou encore un dé de 20 côtés en forme d’icosaèdre. Le nombre de côtés sur les dés change la chance, ou la probabilité de tomber sur un 1. Moins il y a de côtés, plus vous avez de chances d’afficher un 1 et plus il y a de côtés, moins c’est probable. Par exemple, avec un dé à 4 côtés, il y a une chance sur 4 de lancer un 1 et avec un dé de 20 côtés il y a une chance sur 20. Heureusement, Sonic Pi a le très pratique «one_in» fn pour décrire exactement cela. Jouons :

    live_loop :different_probabilities do
      sample :drum_snare_hard if one_in(6)
      sleep 0.125
    end

Lancez la boucle ci-dessus et vous pourrez entendre un rythme aléatoire familier. Cependant, n’arrêtez pas l’exécution du code. Au lieu de cela, changez le `6` pour une valeur différente comme `2` ou `20` et appuyez de nouveau sur le bouton `Run`. Constatez que des nombres inférieurs signifient que le son de caisse claire sera plus fréquent et que des nombres supérieurs signifie que la caisse clair est jouée moins fréquemment. Vous faites de la musique avec des probabilités !

## Combiner les probabilités

Les choses deviennent vraiment excitantes quand plusieurs échantillons sont joués avec des probabilités différentes. Par exemple :

    live_loop :multi_beat do
      sample :elec_hi_snare if one_in(6)
      sample :drum_cymbal_closed if one_in(2)
      sample :drum_cymbal_pedal if one_in(3)
      sample :bd_haus if one_in(4)
      sleep 0.125
    end

De nouveau, exécutez le code ci-dessus et commencez à changer les probabilités pour modifier le rythme. De plus, essayez de changer les échantillons pour créer une sensation entièrement nouvelle. Par exemple, essayez de changer `:drum_cymbal_closed` par `:bass_hit_c` pour obtenir plus de basse !

## Rythmes répétables

Ensuite, nous pouvons utilisez notre vieil ami `use_random_seed` pour réinitialiser le générateur aléatoire après 8 itérations pour créer un rythme régulier. Tapez le code suivant pour entendre un rythme beaucoup plus régulier et répétitif. Une fois que vous entendez le rythme, essayez de remplacer la valeur `1000` par un autre nombre. Remarquez comme des nombres différents génèrent des rythmes différents.

    live_loop :multi_beat do
      use_random_seed 1000
      8.times do
        sample :elec_hi_snare if one_in(6)
        sample :drum_cymbal_closed if one_in(2)
        sample :drum_cymbal_pedal if one_in(3)
        sample :bd_haus if one_in(4)
        sleep 0.125
      end
    end

Une chose que j’ai tendance à faire avec ce genre de structures, c’est de me rappeler quelles graines aléatoires sonnent bien et de les noter. De cette manière, je peux facilement recréer mes rythmes dans des sessions d’entrainement ou des représentations futures.

## Rassemblons tout

Finalement, nous pouvons ajouter un peu de basse aléatoire pour lui donner un contenu mélodique sympa. Vous pourrez remarquer que nous pouvons aussi utiliser notre méthode de séquençage probabiliste récemment découverte sur les synthés comme sur les échantillons. Nous vous arrêtez pas là pour autant - ajuster les nombres et faites votre propre piste grâce au pouvoir des probabilités !

    live_loop :multi_beat do
      use_random_seed 2000
      8.times do
        c = rrand(70, 130)
        n = (scale :e1, :minor_pentatonic).take(3).choose
        synth :tb303, note: n, release: 0.1, cutoff: c if rand < 0.9
        sample :elec_hi_snare if one_in(6)
        sample :drum_cymbal_closed if one_in(2)
        sample :drum_cymbal_pedal if one_in(3)
        sample :bd_haus, amp: 1.5 if one_in(4)
        sleep 0.125
      end
    end

# - Modulation d’amplitude

Ce mois-ci nous allons plonger en profondeur dans l’un des effets les plus puissants et les plus flexibles de Sonic Pi - le `:slicer`. D’ici la fin de cet article, vous aurez appris comment manipuler le volume global de certaines parties de notre son codé en live de façons nouvelles et puissantes.

## Trancher cet ampli

Alors, que fait réellement l’effet `:slicer` ? Une façon de se le représenter est simplement comme quelqu’un qui joue avec le contrôle du volume de votre TV ou de votre chaîne hi-fi. Voyons cela, mais d’abord, écoutez le grognement profond produit par le code suivant qui utilise le synthé `:prophet` :

    synth :prophet, note: :e1, release: 8, cutoff: 70
    synth :prophet, note: :e1 + 4, release: 8, cutoff: 80

Maintenant, passons le à travers l’effet `:slicer` :

    with_fx :slicer do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

Écoutez comme le `:slicer` fait comme s’il coupait puis rétablissait le son à un rythme régulier. Observez aussi comme le `:slicer` affecte tout le son généré entre les blocs `do` et `end`. Vous pouvez contrôler la vitesse à laquelle il coupe et rétablit le son avec l’option `phase:` qui est l’abréviation de “durée de phase”. Sa valeur par défaut est `0.25` ce qui signifie 4 fois par seconde au rythme par défaut de 60 BPM. Accélérons le :

    with_fx :slicer, phase: 0.125 do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

Maintenant, jouez avec différentes durées `phase :` vous-même. Essayez des valeurs de plus en plus courtes. Voyez ce qui se passe lorsque vous choisissez une valeur vraiment courte. Essayez également différents synthés tels que `:beep` ou`:dsaw` et différentes notes. Jetez un œil au diagramme suivant pour voir comment les différentes valeurs de `phase :` changent le nombre de changements d’amplitude par battement.

La durée de phase est la durée d’un cycle on/off. De ce fait, des valeurs plus petites feront que l’effet alternera entre on et off beaucoup plus rapidement qu’avec des valeurs plus grandes. De bonnes valeurs pour commencer à jouer sont `0.125`, `0.25`, `0.5` et `1`.

## Ondes de contrôle

Par défaut, l’effet `:slicer` utilise une onde carrée pour manipuler l’amplitude au fil du temps. C’est pour cela que l’on entend l’amplitude pendant une période, puis elle est immédiatement coupée pendant une période, puis remise en marche. Il se trouve que l’onde carrée est juste l’une des 4 différentes ondes de contrôle supportée par le `:slicer`. Les autres sont l’onde en dent de scie (saw), l’onde triangle et l’onde (co)sinus. Regardez le diagramme ci-dessous pour voir à quoi elles ressemblent. On peut aussi entendre comment elles sonnent. Par exemple, le code suivant utilise l’onde (co)sinus comme onde de contrôle. Remarquez comme le son n’est pas coupé puis remis brusquement, mais au lieu de cela, augmente et diminue doucement :

    with_fx :slicer, phase: 0.5, wave: 3 do
      synth :dsaw, note: :e3, release: 8, cutoff: 120
      synth :dsaw, note: :e2, release: 8, cutoff: 100
    end

Jouez avec les différentes formes d’ondes en changeant l’option `wave:` à `0` pour la dent de scie, `1` pour l’onde carrée, `2` pour l’onde triangle et `3` pour la sinusoïde. Voyez aussi comme les différentes ondes sonnent avec des options `phase:` différentes.

Chacune de ces ondes peut être inversée avec l’option `invert_wave:` qui la retourne sur l’axe y. Par exemple, lors d’une phase, l’onde en dent de scie commence typiquement à l’état haut puis descend doucement avant de sauter d’un coup à l’état haut. Avec `invert_wave: 1`, elle va commencer à l’état bas, puis monter doucement avant de sauter de nouveau à l’état bas. De plus, l’onde de contrôle peut démarrer à différents points avec l’option `phase_offset:` qui prend une valeur entre `0` et `1`. En jouant avec les options `phase:`, `wave:`, `invert_wave:` et `phase_offset`, vous pouvez changer drastiquement la façon dont l’amplitude est modulée au cours du temps.

## Régler vos niveaux

Par défaut, le `:slicer` alterne entre les valeurs d’amplitude `1` (volume max nominal) et `0` (silencieux). Ceci peut être changé avec les options `amp_min:` et `amp_max:`. Vous pouvez utiliser ceci en parallèle du réglage d’onde sinusoïdale pour créer un effet de trémolo simple :

    with_fx :slicer, amp_min: 0.25, amp_max: 0.75, wave: 3, phase: 0.25 do
      synth :saw, release: 8
    end

C’est comme attraper le bouton de volume de votre chaîne hi-fi et le bouger légèrement de haut en bas pour que le volume oscille.

## Probabilités

L’une des fonctionnalités puissantes de `:slicer` est sa capacité à utiliser la probabilité pour choisir d’activer ou pas le slicer. Avant que le FX `:slicer` ne commence une nouvelle phase, il lance un dé et, en fonction du résultat, utilise l’onde de contrôle sélectionnée ou maintient l’amplitude désactivée. Écoutons :

    with_fx :slicer, phase: 0.125, probability: 0.6  do
      synth :tb303, note: :e1, cutoff_attack: 8, release: 8
      synth :tb303, note: :e2, cutoff_attack: 4, release: 8
      synth :tb303, note: :e3, cutoff_attack: 2, release: 8
    end

Ecoutez comme nous avons maintenant un rythme de pulsations intéressant. Essayez de changer l’option `probability:` vers une valeur différente entre `0` et `1`. Les valeurs plus proches de `0` provoqueront plus d’espacement entre les sons, dû à la probabilité beaucoup plus basse que le son soit déclenché.

Une autre chose à remarquer, est que le système de probabilités dans l’effet FX est identique à celui qui est accessible via les fonctions comme `rand` et `shuffle`. Ils sont tous les deux complètement déterministes. Cela signifie qu’à chaque fois que vous appuyez sur le bouton `executer`, vous entendrez exactement le même rythme de pulsations pour une probabilité donnée. Si vous voulez changer les choses, vous pouvez utiliser l’option `seed:` pour sélectionner une graine de départ différente. Cela fonctionne exactement comme `use_random_seed` mais affecte uniquement cet effet particulier.

Enfin, vous pouvez changer la “position de repos” de l’onde de contrôle quand le test de probabilité échoue, de `0` à n’importe quelle autre position avec l’option `prob_pos:` :

    with_fx :slicer, phase: 0.125, probability: 0.6, prob_pos: 1  do
      synth :tb303, note: :e1, cutoff_attack: 8, release: 8
      synth :tb303, note: :e2, cutoff_attack: 4, release: 8
      synth :tb303, note: :e3, cutoff_attack: 2, release: 8
    end

## Tranchage de rtythmes

Une chose très amusante à faire est d’utiliser le `:slicer` pour découper un rythme de batterie :

    with_fx :slicer, phase: 0.125 do
      sample :loop_mika
    end

Ceci nous permet de prendre n’importe quel échantillon et de créer de nouvelles possibilités rythmiques, ce qui est très amusant. Cependant, une chose pour laquelle il faut être prudent est de s’assurer que le tempo de l’échantillon correspond au rythme actuel dans Sonic Pi, sinon la découpe sonnera totalement décalée. Par exemple, essayez de remplacer `:loop_mika` avec l’échantillon `loop_amen` pour entendre comme cela sonne mal quand les tempo ne s’alignent pas.

## Modifier le tempo

Comme vous avez pu le voir, changer le BPM par défaut avec `use_bpm` fera s’accroitre ou se réduire les temps de pause et les durées d’enveloppe des synthés pour correspondre avec le tempo. L’effet `:slicer` honorera cela aussi, car l’option `phase:` est en fait mesurée en pulsation et non en secondes. Nous pouvons donc régler le problème avec `loop_amen` en changeant le BPM pour qu’il corresponde à l’échantillon :

    use_sample_bpm :loop_amen
    with_fx :slicer, phase: 0.125 do
      sample :loop_amen
    end

## Rassemblons tout

Appliquons ces idées dans un dernier exemple qui utilise uniquement l’effet `:slicer` pour créer une combinaison intéressante. Allez-y, commencez à le modifier et à en faire votre propre morceau !

    live_loop :dark_mist do
      co = (line 70, 130, steps: 8).tick
      with_fx :slicer, probability: 0.7, prob_pos: 1 do
        synth :prophet, note: :e1, release: 8, cutoff: co
      end

      with_fx :slicer, phase: [0.125, 0.25].choose do
        sample :guit_em9, rate: 0.5
      end
      sleep 8
    end
    live_loop :crashing_waves do
      with_fx :slicer, wave: 0, phase: 0.25 do
        sample :loop_mika, rate: 0.5
      end
      sleep 16
    end

# - Cinq techniques de Live Coding

Dans le tutoriel Sonic Pi de ce mois-ci, nous allons regarder comment vous allez pouvoir commencer à traiter Sonic Pi comme un véritable instrument. Nous allons donc devoir commencer à penser au code d’une façon complètement différente. Les live coders voient le code de la même façon que les violonistes voient leur archet. En fait, tout comme un violoniste peut appliquer différentes méthodes d’archet pour créer des sons différents (des mouvements lents et amples ou des touches rapides et courtes) nous allons explorer cinq des techniques de base de live coding que permet Sonic Pi. À la fin de cet article, vous serez capables de commencer à vous entrainer pour vos propres représentations de live coding.

## 1. Mémoriser les raccourcis

Le premier truc pour live coder avec Sonic Pi est de commencer à utiliser les raccourcis. Par exemple, au lieu de perdre un temps précieux à atteindre la souris, la déplacer sur le bouton d’exécution et cliquer dessus, vous pouvez simplement appuyer simultanément sur `alt` et `r`, ce qui est beaucoup plus rapide et garde vos doigts sur le clavier, prêts pour la prochaine édition. Vous pouvez trouver les raccourcis pour les principaux boutons en haut, en passant la souris au dessus d’eux. Voyez la section 10.2 du tutoriel inclus pour la liste complète des raccourcis.

Lorsque vous jouez, une chose amusante à faire est d’ajouter un peu de style à votre mouvement de bras lorsque vous utilisez des raccourcis. Par exemple, il est souvent bien de communiquer avec votre public quand vous êtes sur le point de faire un changement. Embellissez donc votre mouvement quand vous appuyez sur `alt-r` comme le ferait un guitariste lorsqu’il joue un puissant accord.

## 2. Superposer manuellement vos sons

Maintenant que vous pouvez déclencher le code instantanément avec le clavier, vous pouvez instantanément utiliser cette compétence pour notre seconde technique qui est de calquer vos sons manuellement. Au lieu de “composer” en utilisant beaucoup d’appels de “jouer” et “échantillon” séparés par des appels de “dormir”, nous allons avoir un appel de “jouer” que nous allons manuellement déclencher en utilisant “alt-r”. Essayons-le. Taper le code suivant dans un nouveau tampon :

    synth :tb303, note: :e2 - 0, release: 12, cutoff: 90

Maintenant, cliquez sur “Exécuter”. Pendant que le son joue, modifiez le code afin de décrémenter quatre notes en effectuant ce qui suit :

    synth :tb303, note: :e2 - 4, release: 12, cutoff: 90

Maintenant, pressez `Run` de nouveau, pour entendre les deux sons jouer en même temps. Ceci se produit puisque le bouton `Run` de Sonic Pi n’attend pas qu’un code précédent ne se termine et donc le code s’exécute en même temps. Ceci veut dire que vous pouvez facilement superposer plusieurs sons manuellement avec des modifications mineures ou majeures entre chaque déclenchement. Par exemple, essayez de changer la `note:` et l’option de `cutoff:` et de déclencher de nouveau.

Vous pouvez également essayer cette technique avec de longs échantillons abstraits. Par exemple :

    sample :ambi_lunar_land, rate: 1

Essayer de démarrer l’échantillon, et puis progressivement couper de moitié l’option de `rate:` entre les clics de `Run` de `1` à `0.5` à `0.25` à `0.125`. Ensuite, essayez même des valeurs négatives comme `-0.5`. Superposez les sons ensemble et découvrez ce que vous pouvez faire. Finalement, essayez d’ajouter quelques FX.

En direct, travailler ainsi avec des lignes de code simples permet à un public découvrant Sonic Pi de suivre ce que vous faites et de faire le lien entre le code lu et le son entendu, le résultat du code.

## 3. Boucles maîtresses en “live”

Lorsque vous travaillez avec une musique plus rythmée, il est souvent difficile de déclencher tout manuellement et de conserver le bon tempo. A la place, il est souvent mieux d’utiliser une `live_loop`. Cela fournit une répétition de votre code en plus de vous donner la possibilité de modifier le code pour la prochaine itération de la boucle. Ces “boucles en direct”, live loops, vont également être exécutées en même temps que les autres `live_loop`s ce qui signifie que vous pouvez jouer les deux ensemble l’une avec l’autre et programmer manuellement les déclencheurs. Jetez un coup d’œil à la section 9.2 du tutoriel inclus pour plus d’informations à propos du travail avec les boucles en direct.

En direct, pensez à utiliser l’option `live_loop`’s `sync:` pour récupérer des erreurs d’exécution accidentelles qui stoppent la boucle en direct à cause d’une erreur de votre part, erreur de syntaxe par exemple. Si vous avez l’option `sync:` qui pointe vers une autre `live_loop` valide alors vous pouvez rapidement réparer votre erreur de syntaxe et ré-exécuter le code corrigé pour redémarrer les choses sans l’arrêt du morceau complet.

## 4. Utiliser le mixer général

L’un des secrets les mieux gardés de Sonic Pi est qu’il a un mixeur maître par lequel passent tous les flux de sons. Ce mixeur a un filtre de passe basse et un filtre de passe élevé inclus, afin que vous puissiez facilement effectuer des modifications globales au son. La fonctionnalité du mixeur maître est accessible via la fonction `set_mixer_control!`. Par exemple, pendant que du code s’exécute et fait du son, entrez ceci dans un tampon supplémentaire et pressez `Run` :

` set_mixer_control! lpf: 50 `

Ce code une fois exécuté, tous les sons existants et les nouveaux auront un filtre passe-bas qui leur sera appliqué : ils sonneront donc plus étouffés. Notez que cela veut dire que les nouvelles valeurs du mixeur demeurent les mêmes tant qu’elles ne sont pas changées de nouveau. Cependant, si vous le voulez, vous pouvez toujours remettre le mixeur à son état par défaut avec `reset_mixer!`. Quelques unes des options supportées actuellement sont : `pre_amp:`, `lpf:` `hpf:`, et `amp:`. Pour la liste complète, voir la documentation incluse pour `set_mixer_control!`.

Utilisez les options `*_slide` du mixeur pour faire varier, glisser une ou plusieurs valeurs d’option au fil du temps. Par exemple, pour glisser lentement le filtre de passe-bas du mixeur de la valeur courante à 30, utilisez ceci :

    set_mixer_control! lpf_slide: 16, lpf: 30

Vous pouvez désormais glisser rapidement de nouveau vers une valeur haute avec :

    set_mixer_control! lpf_slide: 1, lpf: 130

Lorsque vous jouez, il est souvent utile de conserver un tampon libre pour travailler avec le mixeur comme cela.

## 5. Entraînement

La technique la plus importante pour la programmation en direct est la pratique. Le trait le plus commun au travers des musiciens professionnels de tous les types est qu’ils s’entraînent à jouer avec leur instrument - souvent plusieurs heures par jour. La pratique est aussi importante pour un programmeur en direct qu’un guitariste. La pratique permet à vos doigts de mémoriser certains schémas et éditions communes afin que vous puissiez les tapez et travailler avec eux de manière plus fluide. La pratique vous donne également des opportunités d’explorer des nouveaux sons et des nouvelles constructions de code.

En performant, vous découvrirez que plus vous pratiquez, plus il sera facile pour vous de vous relaxer pendant une séance. La pratique vous donne également une richesse d’expérience de laquelle apprendre. Cela peut vous aider à comprendre quel types de modifications seraient intéressants et également ce qui fonctionne bien avec les sons courants.

## Rassemblons tout

Ce mois-ci, au lieu de vous donner un exemple final qui combine toutes les choses dont nous avons discuté, essayons plutôt de poser un défi. Voyez si vous pouvez passer une semaine à pratiquer l’une de ces idées tous les jours. Par exemple, une journée pratiquez les déclencheurs manuels, la suivante faites du travail basique de `live_loop` et avant que vous ne vous en rendiez compte, vous serez en train de coder en direct pour un vrai public.

# - 8 astuces pour la pratique du codage en direct

Le mois dernier, nous avons étudié cinq techniques importantes pour maitriser le codage en direct - en d’autres mots, nous avons exploré comment nous pouvions utiliser Sonic Pi pour approcher le code de la même façon que nous le ferions avec un instrument de musique. L’un des concepts importants dont nous avons discuté est la pratique. Ce mois-ci, nous allons approfondir notre compréhension de pourquoi la pratique du codage en direct est importante et comment vous pouvez commencer à le faire.

## Pratiquer régulièrement

Le conseil le plus important est de vous assurer de pratiquer régulièrement. Par discipline, je pratique normalement 1-2 heures par jour, mais 20 minutes est correct quand vous débutez. Un petit peu mais souvent est ce que vous visez - donc si vous ne pouvez effectuer que 10 minutes, c’est un bon début.

Astuce de pratique #1 - commencer à développer une routine de pratique. Trouvez un bon moment dans la journée qui vous convient et essayer de pratiquer à ce moment le plus grand nombre de jours dans une semaine que vous pouvez. Vous allez rapidement avoir hâte de faire votre session quotidienne.

## Apprenez à taper sans regarder le clavier

Si vous observez un musicien professionnel qui performe sur scène, vous remarquez certainement quelques éléments. Premièrement, ils ne fixent pas leur instrument lorsqu’ils jouent. Leurs doigts, bras et corps savent quelles sont les touches à appuyer, cordes à gratter ou les tambours à frapper sans avoir trop à y penser. Ceci est connu comme la “mémoire musculaire” et même si cela peut ressembler à quelque chose qu’uniquement les professionnels peuvent faire, c’est la même chose que lorsque vous avez appris à marcher ou à faire de la bicyclette, la pratique par répétition. Les codeurs en direct utilisent leur mémoire musculaire pour libérer leur esprit d’avoir à penser à quel endroit placer leurs doigts afin qu’ils puissent se concentrer sur la musique. Cela s’appelle du tape-touche - taper sans avoir besoin de regarder le clavier.

Astuce de pratique #2 - apprenez comment taper sans regarder le clavier. Il y a plusieurs applications, sites web et même des jeux qui peuvent vous aider à réussir. Trouvez-en un dont vous aimez l’allure et tenez vous en à lui jusqu’à ce que vous soyez capable de programmer sans regarder le clavier.

## Coder en position debout

Le corps d’un musicien est conditionné pour jouer son instrument. Par exemple, un trompettiste doit être capable de souffler fort, un guitariste doit être capable de tenir le manche avec force et un batteur doit être capable de frapper continuellement les tambours pour de longues périodes de temps. Alors, qu’est-ce qui est physique à propos du codage en direct ? Tout comme les DJs, les codeurs en direct performent habituellement debout et certains dansent même en codant ! Si vous pratiquez votre codage en direct assis à un bureau et que vous avez à vous levez pour jouer pour un concert, vous trouverez probablement cette différence difficile et frustrante.

Astuce de pratique #3 - tenez vous debout en pratiquant. La façon la plus facile de faire cela est en utilisant un bureau à usage debout. Par contre, si comme moi vous n’en n’avez pas à la maison, il existe quelques options à faible coût. L’approche que je prends est d’utiliser une table à repasser, ce qui fonctionne assez bien. Une autre façon est d’empiler quelques boites ou de gros livres sur un bureau normal et placer votre clavier sur le dessus. De plus, n’oubliez pas de vous étirez avant de commencer votre pratique et essayez de danser un peu durant votre session. Rappelez-vous, personne ne vous regarde, donc ayez du plaisir et vous vous sentirez beaucoup plus naturel sur scène.

## Mise en place de la pratique

La majorité des instruments nécessitent de l’assemblage et des ajustements avant que vous puissiez en jouer. À moins que vous soyez une étoile du rock avec un autobus rempli de techniciens, vous aurez à mettre en place votre propre instrument avant votre concert. C’est souvent un moment stressant et des problèmes peuvent arriver facilement. Une façon de vous aider avec cela est d’incorporer le processus de mise en place dans vos sessions d’entraînement.

Astuce de pratique #4 - traiter la mise en place comme une partie importante de votre pratique. Par exemple, ayez une boite ou un sac dans lequel vous pouvez conserver votre Raspberry Pi et votre clavier etc. Avant chaque session de pratique, sortez toutes les pièces, connectez tout et aller dans le processus de démarrage jusqu’à ce que vous ayez Sonic Pi qui s’exécute et que vous puissiez faire des sons. A la fin de votre entraînement, prenez le temps de tout remballer minutieusement. Cela peut prendre du temps au départ, mais en peu de temps vous serez capable de mettre en place et emballer tout incroyablement rapidement sans que vous ayez besoin d’y penser.

## Expérimenter musicalement

Une fois que tout est mis en place et que vous êtes prêt à faire de la musique, il se peut que vous ayez de la difficulté à savoir par où commencer. Un problème que plusieurs personnes rencontrent est qu’elles ont une bonne idée du type de sons qu’elles veulent produire, mais elles sont frustrées de ne pas être capable de les produire. Certaines personnes ne savent même pas quel type de sons elles veulent produire ! La première chose à faire est de ne pas s’inquiéter - c’est très commun et ça arrive à tous les musiciens - même s’ils pratiquent depuis longtemps. C’est beaucoup plus important de faire des sons que vous n’aimez pas que de ne pas faire de sons du tout.

Astuce de pratique #5 - passez du temps à faire des sons et de la musique que vous n’aimez pas. Essayez de conserver du temps pour explorer des nouveaux sons et des idées. Ne vous inquiétez pas que cela puisse sonner terrible si ce n’est pas le style que vous recherchez. Quand vous expérimentez de cette manière, vous augmentez les chances de tomber sur un son ou une combinaison de sons que vous aimez ! Même si 99% des sons que vous faites sont mauvais, ce 1% peut être le riff ou l’intro de votre nouvelle piste. Oubliez les choses que vous n’aimez pas et rappelez-vous de celles que vous aimez. C’est encore plus facile quand vous faites de la musique avec du code - vous n’avez qu’à presser sauvegarder !

## Entendre le code

Plusieurs musiciens peuvent regarder une partition de musique et entendre la musique dans leur tête sans avoir à la jouer. C’est une compétence très utile et ça vaut la peine de l’incorporer dans vos sessions de pratique de codage en direct. L’important est d’être capable d’avoir une certaine compréhension de comment va sonner le code. Vous n’avez pas besoin d’être capable de l’entendre exactement dans votre tête, mais il est utile de savoir si le code sera rapide, lent, fort, rythmé, mélodieux, aléatoire, etc. Le but final est d’être capable d’inverser le processus par la suite - être capable d’entendre de la musique dans votre tête et savoir comment la coder. Cela peut vous prendre beaucoup de temps à maîtriser, mais quand c’est le cas, vous serez capable d’improviser sur scène et exprimer vos idées de manière fluide.

Astuce de pratique #6 - écrivez un peu de code dans Sonic Pi, mais ne pressez pas sur le bouton Exécuter. Au lieu de cela, essayez d’imaginer quel son ça va produire. Puis, pressez Exécuter, écoutez, et pensez sur quoi vous aviez raison et sur quoi vous aviez tort. Continuez de répéter cela jusqu’à ce que ça devienne une partie naturelle de votre processus de codage. Quand je pratique, j’ai normalement une bonne idée de comment va sonner le code. Cependant, je suis encore parfois surpris, et alors j’arrête et prends du temps pour penser à propos de quoi j’avais tort. À chaque fois que cela se produit, j’apprends de nouveaux trucs qui me permettent de m’exprimer de nouvelles façons.

## Enlevez toutes les distractions

Un problème courant en pratiquant est de devenir distrait par d’autres choses. La pratique est difficile et demande une réelle discipline peu importe le type de musique que vous jouez - du jazz au EDM en passant par le classique. Si vous avez de la difficulté à commencer ou faire des progrès, c’est souvent trop facile d’aller sur un réseau social, ou de regarder quelque chose sur internet etc. Si vous vous êtes fixé un objectif d’une pratique d’une durée de 20 minutes, c’est important d’essayer de prendre tout ce temps en étant le plus productif possible.

Astuce de pratique #7 - avant de commencer votre pratique, enlevez le plus de distractions possible. Par exemple, déconnectez-vous d’internet, laissez votre téléphone dans une autre pièce et essayez de pratiquer dans un endroit tranquille où il est peu probable que vous soyez dérangé. Essayez de vous concentrer sur le codage de la musique et vous pourrez retourner à vos distractions quand vous aurez terminé.

## Tenir un journal d’entraînement

Quand vous pratiquez, vous ressentirez souvent que votre esprit est plein de nouvelles idées enthousiasmantes - nouvelles directions musicales, nouveaux sons à essayer, nouvelles fonctions à écrire, etc. Ces idées sont souvent tellement intéressantes que vous allez peut-être interrompre ce que vous faisiez pour commencer à travailler sur l’idée. Il s’agit d’une autre forme de distraction !

Astuce de pratique #8 - conservez un journal de pratique près de votre clavier. Quand vous avez une nouvelle idée excitante, arrêtez temporairement votre session, notez rapidement l’idée, et puis oubliez la pour continuer à pratiquer. Vous pouvez par la suite passer du temps de qualité à penser et à travailler vos idées une fois que vous avez terminé de pratiquer.

## Rassemblons tout

Essayez d’établir une routine de pratique qui inclut autant de ces idées que possible. Essayez de rendre les sessions aussi plaisantes que possible, mais soyez prévenus que certaines sessions de pratiques seront difficiles et auront l’apparence d’un travail. Toutefois, tout cela aura valu la peine lorsque vous aurez créé votre première pièce ou que vous aurez donné votre première performance. Rappelez-vous, la pratique est la clé du succès !

# - Étirement de l’échantillon

Lorsque les personnes découvrent Sonic Pi, l’une des premières choses qu’ils apprennent est combien il est facile de jouer des sons pré-enregistrés en utilisant la fonction `sample`. Par exemple, vous pouvez faire jouer une boucle de batterie industrielle, entendre le bruit d’une chorale ou même écouter le “scratch” d’un vinyle, tout ça via une seule ligne de code. Cependant, plusieurs personnes ne réalisent pas que vous pouvez varier la vitesse à laquelle l’échantillon est joué pour ajouter des effets puissants et un tout nouveau niveau de contrôle sur vos sons enregistrés. Alors, lancez une copie de Sonic Pi et commençons à étirer quelques échantillons !

## Ralentissement des échantillons

Pour modifier la vitesse à laquelle joue un échantillon, nous devons utiliser l’option `rate:` :

    sample :guit_em9, rate: 1

Si nous spécifions un `rate:` de `1`, alors l’échantillon sera joué à une vitesse normale. Si nous voulons le jouer à une vitesse réduite de moitié, nous utilisons tout simplement un `rate:` de `0.5` :

    sample :guit_em9, rate: 0.5

Notez comme cela a deux effets sur l’audio. Premièrement l’échantillon sonne plus bas et deuxièmement il prend deux fois plus de temps à jouer (voir la barre latérale pour une explication). Nous pouvons même choisir des vitesses de plus en plus basses jusqu’à `0`, donc un `rate:` de `0.25` est un quart de la vitesse, `0.1` un dixième de la vitesse, etc. Essayez de jouer avec des vitesses lentes et de voir si vous pouvez transformer le son en un grondement.

## Accélération des échantillons

En plus de rendre le son plus long et grave en utilisant une petite vitesse, nous pouvons utiliser des vitesses plus rapides pour rendre le son plus court et aigu. Jouons avec une boucle de batterie pour cette fois-ci. Premièrement, écoutez comment cela sonne à la vitesse par défaut de `1` :

    sample :loop_amen, rate: 1

Maintenant, accélérons un peu les choses :

    sample :loop_amen, rate: 1.5

Ah ! Nous venons de passer du genre music techno vieille école à la jungle. Remarquer comment la fréquence de chaque coup de tambour est plus grande ainsi que le rythme complet qui est accéléré. Maintenant, essayer des taux encore plus grands et voyez comment haut et court vous pouvez modifier la boucle de batterie. Par exemple, si vous utilisez le taux de `100`, la boucle de batterie tourne en un clic !

## Marche arrière

A présent, je suis sûr que beaucoup d’entre vous pensent la même chose… “qu’est-ce qu’il se passe si j’utilise une valeur négative pour la vitesse ?”. Excellente question ! Réfléchissons-y un court instant. Si notre `rate:` désigne la vitesse à laquelle l’échantillon est joué, `1` étant la vitesse normale, `2` étant deux fois plus rapide, `0.5` étant deux fois plus lent, `-1` doit vouloir dire à l’envers ! Essayons ça sur une caisse claire. Pour commencer, rejouez à la vitesse normale :

    sample :elec_filt_snare, rate: 1

Maintenant, jouez le à l’envers :

    sample :elec_filt_snare, rate: -1

Bien entendu, vous pouvez le jouer à l’envers deux fois plus vite avec un `rate:` de `-2` ou à l’envers deux fois plus lentement avec un `rate:` de `-0.5`. Maintenant, amusez-vous à jouer avec différentes valeurs négatives. C’est particulièrement amusant avec l’échantillon `:misc_burp` !

## Échantillon, Vitesse et Hauteur

L’un des effets de la modification de la vitesse sur les échantillons est que plus la vitesse est importante plus l’échantillon sonne aigu, et plus la vitesse est basse plus l’échantillon sonne grave. Un autre endroit où vous avez pu entendre cet effet est dans la vie de tous les jours lorsque vous faites du vélo ou que vous passez près d’un passage piéton qui émet un bip sonore - lorsque vous vous approchez de la source sonore le son est plus aigu que lorsque vous vous en éloignez - c’est ce que l’on appelle l’effet Doppler. Pourquoi cela ?

Considérons un simple bip qui est représenté par une onde sinusoïdale. Si nous utilisons un oscilloscope pour tracer ce bip, nous verrons quelque chose comme la figure A. Si nous traçons le bip une octave plus aiguë, nous verrons la figure B et une octave plus grave ressemblera à la figure C. Remarquez que les ondes des notes aiguës sont plus compactes tandis que celles des notes graves sont plus étendues.

Un échantillon d’un bip n’est rien de plus que beaucoup de nombres (x,y, coordonnées) qui, lorsque tracé point par point sur un graphique, dessinera de nouveau les courbes originales. Voyez la figure D où chaque cercle représente une coordonnée. Pour convertir de nouveau les coordonnées en audio, l’ordinateur travaille avec chaque valeur x et envoie chaque valeur y correspondante aux haut-parleurs. L’astuce ici est que la vitesse à laquelle l’ordinateur travaille avec les nombres x n’a pas besoin d’être la même que la vitesse à laquelle ils ont été enregistrés. En d’autres mots, l’espace (représentant une quantité de temps) entre chaque cercle peut être étiré ou compressé. Donc, si l’ordinateur travaille plus rapidement avec les valeurs x que la vitesse originale, cela aura l’effet d’écraser les cercles ensemble ce qui résultera en un bip sonnant plus aigu. Cela va également rendre le bip plus court étant donné que nous allons naviguer plus rapidement au travers des cercles. Cela est démontré dans la figure E.

Finalement, une dernière chose à savoir est qu’un mathématicien appelé Fourier a prouvé que tout son est beaucoup d’ondes sinusoïdales combinées toutes ensemble. Donc, quand nous compressons et étirons quelconque son enregistré, nous étirons et compressons plusieurs ondes sinusoïdales ensemble en même temps de cette manière exactement.

## Effet Pitch Bend

Comme nous l’avons vu, utiliser une vitesse plus rapide rendra le son plus aigu et une vitesse plus lente rendra le son plus grave. Une astuce très simple et utile est de savoir que doubler la vitesse résultera en un son qui est une octave plus aiguë et inversement, diminuer la vitesse de moitié rendra le son une octave plus grave. Cela veut dire que, pour les échantillons mélodiques, les faire jouer en même temps que lui-même à une vitesse doublée ou divisée de moitié sonne plutôt bien :

    sample :bass_trance_c, rate: 1
    sample :bass_trance_c, rate: 2
    sample :bass_trance_c, rate: 0.5

Cependant, comment devons-nous faire si nous voulons modifier la vitesse afin que le son soit un demi-ton plus aigu (une note plus aiguë sur le piano) ? Sonic Pi rend cela très facile avec l’option `rpitch:` :

    sample :bass_trance_c
    sample :bass_trance_c, rpitch: 3
    sample :bass_trance_c, rpitch: 7

Si vous regardez le journal à droite, vous remarquerez qu’un `rpitch:` de `3` correspond en fait à un rythme de `1.1892` et qu’un `rpitch:` de `7` correspond à un rythme de `1.4983`. Finalement, nous pouvons même combiner les options `rate:` et `rpitch:` :

    sample :ambi_choir, rate: 0.25, rpitch: 3
    sleep 3
    sample :ambi_choir, rate: 0.25, rpitch: 5
    sleep 2
    sample :ambi_choir, rate: 0.25, rpitch: 6
    sleep 1
    sample :ambi_choir, rate: 0.25, rpitch: 1

## Rassemblons tout

Jetons un coup d’œil à un morceau simple qui combine ces idées. Copiez-le dans un tampon Sonic Pi vide, pressez jouer, écoutez-le un moment et ensuite utilisez-le comme point de départ pour votre propre morceau. Voyez comment c’est plaisant de manipuler la vitesse de lecture des échantillons. En tant qu’exercice supplémentaire, essayez d’enregistrer vos propres sons et de jouer avec la vitesse pour voir quels sons fous vous pouvez faire.

    live_loop :beats do
      sample :guit_em9, rate: [0.25, 0.5, -1].choose, amp: 2
      sample :loop_garzul, rate: [0.5, 1].choose
      sleep 8
    end

    live_loop :melody do
      oct = [-1, 1, 2].choose * 12
      with_fx :reverb, amp: 2 do
        16.times do
          n = (scale 0, :minor_pentatonic).choose
          sample :bass_voxy_hit_c, rpitch: n + 4 + oct
          sleep 0.125
        end
      end
    end

# - Synthèse additive

Ceci est le premier d’une courte série d’articles sur comment utiliser Sonic Pi pour le design du son. Nous allons faire un tour rapide d’un nombre de techniques différentes disponibles pour fabriquer votre propre son unique. La première technique que nous allons regarder est appelée synthèse additive. Cela peut sembler compliqué - mais si nous développons chaque mot légèrement, la signification en ressort rapidement. Premièrement, additif signifie une combinaison de choses et deuxièmement, synthèse signifie de créer un son. Ainsi, la synthèse additive ne signifie rien de plus compliqué que combiner des sons existants pour en créer des nouveaux. Cette technique de synthèse date de très longtemps - par exemple, les orgues du Moyen Âge avaient beaucoup de tuyaux sonnant légèrement différents que vous pouviez activer ou désactiver avec des arrêts. Tirer sur l’arrêt pour un certain tuyau ‘l’ajoutait au mélange’ ce qui rendait le son plus riche et complexe. Maintenant, voyons comment nous pouvons tirer tous les arrêts avec Sonic Pi.

## Combinaisons simples

Commençons avec le son le plus basique qu’il existe - l’humble onde sinusoïdale aux tons purs :

    synth :sine, note: :d3

Maintenant, voyons comment cela sonne combiné avec une onde carrée :

    synth :sine, note: :d3
    synth :square, note: :d3

Remarquez comment les deux sons se combinent pour former un nouveau son plus riche. Bien sûr, nous n’avons pas à nous arrêter là, nous pouvons ajouter autant de sons que nous avons besoin. Cependant, nous devons être prudent avec combien de sons nous ajoutons ensemble. Tout comme lorsque nous mélangeons des peintures ensembles pour créer de nouvelles couleurs, ajouter trop de couleurs résultera en un brun laid, similairement - ajouter trop de sons ensemble résultera en un son boueux.

## Mélange

Ajoutons quelque chose pour le faire sonner un peu plus clair. Nous pourrions utiliser une onde triangulaire à une octave supérieure ( pour ce haut son clair) encore le jouer seulement à un amplificateur de `0.4` pour qu’il ajoute quelque chose d’extra au son au lieu de le remplacer :

    synth :sine, note: :d3
    synth :square, note: :d3
    synth :tri, note: :d4, amp: 0.4

Maintenant, essayez de créer vos propres sons en combinant 2 synthés ou plus à des octaves et des amplitudes différentes. Également, notez que vous pouvez jouer avec les options de chaque synthé en modifiant chaque source avant qu’elle soit mélangée pour encore plus de combinaisons de sons.

## Désaccordage

Jusqu’à maintenant, lorsque nous combinons nos différents synthés nous avons utilisé soit le même ton ou une octave changée. Comment cela peut-il sonner si nous ne nous n’en tenons pas qu’aux octaves et que nous choisissons à la place une note légèrement plus aiguë ou grave ? Essayons-le :

    detune = 0.7
    synth :square, note: :e3
    synth :square, note: :e3 + detune

Si nous désaccordons nos ondes carrées par 0.7 note, nous entendrons quelque chose qui ne sonnera pas accordé ou correct - une ‘mauvaise’ note. Cependant, en se rapprochant de 0, cela va sonner de moins en moins en désaccord alors que les tons des deux ondes se rapprochent et sont plus similaires. Essayez-le par vous-même ! Changer la valeur de l’option `detune:` de `0.7` à `0.5` et écoutez le nouveau son. Essayer `0.2`, `0.1`, `0.05`, `0`. Chaque fois que vous changez la valeur, écoutez et voyez si vous êtes capables de déterminer comment le son change. Remarquez que les valeurs basses de désaccordage comme `0.1` produisent un très beau son `dense`, avec deux tons différents qui interagissent l’un avec l’autre de manière intéressante, parfois surprenante.

Certains des synthés intégrés proposent déjà une option de “désaccord” qui fait exactement cela en un seul synthé. Essayer de jouer avec l’option de `detune:` de `:dsaw`, `:dpulse` et `:dtri`.

## Façonner l’amplitude

Une autre manière de fabriquer notre son finement est d’utiliser une enveloppe différente et des options pour chaque déclenchement de synthé. Par exemple, cela vous permettra de rendre certains aspects du son percutant et d’autres aspects résonner pour une période de temps.

    detune = 0.1
    synth :square, note: :e1, release: 2
    synth :square, note: :e1 + detune, amp: 2, release: 2
    synth :gnoise, release: 2, amp: 1, cutoff: 60
    synth :gnoise, release: 0.5, amp: 1, cutoff: 100
    synth :noise, release: 0.2, amp: 1, cutoff: 90

Dans l’exemple ci-dessus, j’ai mélangé un élément de bruit percutant dans le son avec quelques grondements de fond plus persistants. Cela a été réalisé en utilisant deux bruits de synthés avec des valeurs (`90` et `100`) de coupures de milieu en utilisant de courts repos avec un plus long temps de repos mais avec une basse valeur de coupure (ce qui rend le son moins impeccable et plus grondant.)

## Rassemblons tout

Combinons toutes ces techniques pour voir si nous pouvons utiliser la synthèse additive pour recréer un son de cloche basique. J’ai découpé cet exemple en quatre sections. Premièrement, nous avons la section `hit` qui est la partie d’initialisation du son de cloche - alors utiliser une enveloppe courte (c.a.d une `release:` autour de `0.1`). Ensuite, nous avons la longue section de tintement dans laquelle j’utilise le son pur de l’onde sinusoïdale. Remarquez que j’augmente souvent la note par environ `12` et `24` qui sont les nombres des notes dans une et deux octaves. J’ai également mis quelques ondes sinusoïdales graves pour donner plus de basses et de profondeur au son. Finalement, j’ai utilisé `define` pour regrouper mon code dans une fonction que je peux utiliser pour jouer une mélodie. Essayer de jouer votre propre mélodie et également de vous amuser avec le contenu de la fonction `:bell` jusqu’à ce que vous ayez créé votre propre son de délire avec lequel jouer !

    define :bell do |n|
      # Ondes en triangle pour la "percussion"
      synth :tri, note : n - 12, release : 0.1
      synth :tri, note : n + 0.1, release : 0.1
      synth :tri, note : n - 0.1, release : 0.1
      synth :tri, note : n, release : 0.2
      # Ondes en forme sinusoïdales pour le "tintement"
      synth :sine, note : n + 24, release : 2
      synth :sine, note : n + 24.1, release : 2
      synth :sine, note : n + 24.2, release : 0.5
      synth :sine, note : n + 11.8, release : 2
      synth :sine, note : n, release : 2
      # Ondes sinusoïdales lentes pour les basses
      synth :sine, note : n - 11.8, release : 2
      synth :sine, note : n - 12, release : 2
    end
    # joue une melodie avec notre nouvelle cloche
    bell :e3
    sleep 1
    bell :c2
    sleep 1
    bell :d3
    sleep 1
    bell :g2

# - Synthèse soustractive

Ceci est le deuxième d’une série d’articles sur comment utiliser Sonic Pi pour le design du son. Le mois dernier, nous avons étudié la synthèse additive dont nous avons découvert qu’il s’agissait simplement de jouer de multiples sons en même temps pour fabriquer un nouveau son combiné. Par exemple, nous pourrions combiner des synthés qui sonnent différemment ou même reprendre le même synthé avec plusieurs hauteurs pour construire un nouveau son complexe à partir d’ingrédients simples. Ce mois-ci, nous allons étudier une nouvelle technique communément appelée “synthèse soustractive” qui est le fait de prendre un son existant complexe et d’en retirer certaines parties pour créer quelque chose de nouveau. Il s’agit d’une technique qui est associée couramment avec le son des synthétiseurs analogiques des années 1960 et 1970, mais également avec la renaissance récente des synthétiseurs analogiques modulaires à travers des standards populaires comme Eurorack.

Même si cela semble être une technique particulièrement compliquée et avancée, Sonic Pi rend cela étonnamment facile et simple - alors commençons dès maintenant.

## Signal source complexe

Pour qu’un son se travaille bien avec la synthèse soustractive, il faut habituellement qu’il soit riche et intéressant. Cela ne veut pas dire que nous avons besoin de quelque chose d’extrêmement complexe - en fait, juste une onde standard `:square` ou `:saw` fonctionnera :

    synth :saw, note: :e2, release: 4

Notez que ce son est déjà assez intéressant et contient plusieurs fréquences différentes au-dessus de `:e2` (le second E sur un piano) ce qui aide à créer le timbre. Si cela ne fait pas trop de sens pour vous, essayez de le comparer avec le `:beep` :

    synth :beep, note: :e2, release: 4

Étant donné que le synthé `:beep` est seulement une onde sinusoïdale, vous entendrez une tonalité beaucoup plus pure, seulement `:e2`, et rien des sons hauts grinçants que vous avez entendu avec `:saw`. C’est cet effet et la variation d’une onde sinusoïdale pure avec lesquels nous pouvons jouer en utilisant la synthèse soustractive.

## Filtres

Une fois que nous avons notre signal source, la prochaine étape est d’appliquer un filtre d’un type qui modifiera le son en retirant ou en réduisant des parties de celui-ci. L’un des filtres les plus communs utilisés pour la synthèse soustractive est celui appelé le filtre passe-bas. Cela permet à toutes les parties basses du son de passer, mais il va réduire ou retirer les parties plus hautes. Sonic Pi a un système d’effets puissant, mais simple, à utiliser qui inclut un filtre passe-bas, appelé `:lpf`. Jouons avec :

    with_fx :lpf, cutoff: 100 do
      synth :saw, note: :e2, release: 4
    end

Si vous écoutez attentivement, vous entendrez comment ces grincements ont été retirés. En fait, toutes les fréquences dans le son qui sont au-dessus de la note `100` ont été réduites ou retirées et seulement celles en dessous sont toujours présentes dans le son. Essayez de changer ce point `cutoff:` à des notes plus basses, disons `70` puis `50` et comparer les sons.

Évidemment, le `:lpf` n’est pas le seul filtre que vous pouvez utiliser pour manipuler le signal source. Un autre effet important est le filtre passe-haut, dénommé `:hpf` dans Sonic Pi. Il fait le contraire de `:lpf` en laissant les parties hautes du son passées et en coupant les parties basses.

    with_fx :hpf, cutoff: 90 do
      synth :saw, note: :e2, release: 4
    end

Notez comment ce son est beaucoup plus grinçant maintenant que toutes les fréquences basses du son ont été retirées. Jouez avec la valeur de coupure - remarquez comment des valeurs plus basses laissent plus de parties basses du son original source passer et que les valeurs plus hautes sonnent plus petites et silencieuses.

## Filtre passe-bas

Le filtre passe-bas est une partie si importante de chaque boîte à outils de synthèse soustractive qu’il vaut la peine d’examiner de plus près comment il fonctionne. Ce diagramme montre la même onde sonore (le synthé `:prophet`) avec une quantité de filtrages variés. En haut, la section A montre l’onde audio sans filtrage. Remarquez comment la forme d’onde est très pointue et contient beaucoup d’arêtes vives. Ce sont ces angles durs et aigus qui produisent les composantes aiguës croustillantes / bourdonnantes du son. La section B montre le filtre passe-bas en action - remarquez comment il est moins pointu et plus arrondi que la forme d’onde ci-dessus. Cela signifie que le son aura moins de hautes fréquences, ce qui lui donnera une sensation arrondie plus douce. La section C montre le filtre passe-bas avec une valeur de coupure assez faible - cela signifie que davantage de hautes fréquences ont été supprimées du signal, ce qui donne une forme d’onde encore plus douce et plus ronde. Enfin, notez comment la taille de la forme d’onde, qui représente l’amplitude, diminue lorsque nous passons de A à C. La synthèse soustractive fonctionne en supprimant des parties du signal, ce qui signifie que l’amplitude globale est réduite en fonction de la quantité de filtrage appliquée.

## Filtre de modulation

Jusqu’à maintenant, nous avons produit des sons assez statiques. En d’autres mots, le son ne change en aucune façon pour toute sa durée. Souvent, vous voudrez peut-être donner du mouvement à un son afin de donner de la vie à son timbre. Une façon d’accomplir cela est avec le filtre de modulation - en changeant les options du filtre au travers du temps. Heureusement, Sonic Pi vous offre des outils puissants pour manipuler les options d’un FX au fil du temps. Par exemple, vous pouvez définir un temps de glissement à chaque option modulable pour spécifier combien de temps cela devrait-il prendre de glisser de la valeur actuelle vers la valeur cible :

    with_fx :lpf, cutoff: 50 do |fx|
      control fx, cutoff_slide: 3, cutoff: 130
      synth :prophet, note: :e2, sustain: 3.5
    end

Jetons un coup d’œil rapide à ce qui se passe ici. Premièrement, nous commençons avec un bloc FX `:lpf` avec un `cutoff:` initial d’un très bas `20`. Cependant, la première ligne termine également avec l’étrange `|fx|` à la fin. C’est une partie optionnelle de la syntaxe `with_fx` qui vous permet de nommer directement et de contrôler le synthé FX qui s’exécute. La ligne 2 fait exactement cela et contrôle le FX pour définir la valeur de l’option `cutoff_slide:` à 4 et la nouvelle cible de `cutoff:` à `130`. Ce FX commencera donc à glisser la valeur de l’option `cutoff:` de `50` à `130` sur une période de trois temps. Finalement, nous déclenchons également un synthé de signal source pour que nous puissions entendre l’effet du filtre passe-bas modulé.

## Rassemblons tout

Ceci est seulement un avant-goût très basique de ce qui est possible quand vous utilisez les filtres pour modifier et changer un son source. Essayez de jouer avec les nombreux effets inclus dans Sonic Pi pour voir quels sons fous vous pouvez concevoir. Si votre son semble trop statique, rappelez-vous que vous pouvez commencer à moduler les options pour créer du mouvement.

Terminons en créant une fonction qui jouera un nouveau son créé avec la synthèse soustractive. Voyez si vous pouvez déterminer ce qui se passe - et pour les lecteurs avancés de Sonic Pi - voyez si vous pouvez trouver pourquoi j’ai tout enveloppé à l’intérieur d’un appel `at` (s’il-vous-plait envoyez vos réponses à @samaaron sur Twitter).

    define :subt_synth do |note, sus|
      at do
        with_fx :lpf, cutoff: 40, amp: 2 do |fx|
          control fx, cutoff_slide: 6, cutoff: 100
          synth :prophet, note: note, sustain: sus
        end
        with_fx :hpf, cutoff_slide: 0.01 do |fx|
          synth :dsaw, note: note + 12, sustain: sus
          (sus * 8).times do
            control fx, cutoff: rrand(70, 110)
            sleep 0.125
          end
        end
      end
    end
    subt_synth :e1, 8
    sleep 8
    subt_synth :e1 - 4, 8

# - Codage créatif en classe avec Sonic Pi

(Cet article a été publié en anglais dans le numéro 9 du magazine Hello World)

Le code est l’un des médias les plus créatifs que les humains aient créés. Les symboles initialement obscurs des parenthèses et des lambdas ne sont pas seulement profondément enracinés dans les sciences et les mathématiques, ils sont les plus proches que nous ayons réussi à obtenir pour jeter le même genre de sorts magiques que Gandalf et Harry Potter. Je crois que cela constitue un moyen puissant d’engagement dans nos espaces d’apprentissage. Grâce à la magie du code, nous sommes en mesure d’évoquer des histoires et des expériences d’apprentissage qui ont un sens pour chacun d’entre nous.

Nous sommes entourés d’expériences magiques. Du tour de passe-passe d’un magicien de scène faisant disparaître le ballon dans les airs, à l’émerveillement de voir son groupe préféré se produire sur une grande scène. Ce sont ces moments magiques qui nous inspirent à prendre un livre de magie et apprendre le French Drop ou pour commencer à jouer des accords de puissance sur une vieille guitare. Comment pourrions-nous créer un sens de l’émerveillement aussi profond et durable qui motivera les gens à pratiquer et à apprendre les bases de la programmation ?

## Moteurs musicaux et notation

Les histoires de la musique et de l’informatique sont intimement liées depuis la création des machines informatiques, ou “moteurs”, comme on appelait le puissant moteur analytique de Charles Babbage. En 1842, la mathématicienne Ada Lovelace, qui a travaillé en étroite collaboration avec Babbage, a vu le potentiel créatif de ces moteurs. Alors que ces premiers moteurs avaient été conçus à l’origine pour résoudre avec précision des problèmes mathématiques difficiles, Ada rêvait de faire de la musique avec eux :

“…le moteur pourrait composer des morceaux de musique élaborés et scientifiques de n’importe quel degré de complexité ou d’ampleur.” Ada Lovelace, 1842.

Bien sûr, aujourd’hui en 2019, une grande partie de notre musique, quel que soit le genre, a été composée, produite ou masterisée avec un ordinateur numérique. Le rêve d’Ada est devenu réalité. Il est même possible de remonter encore plus loin dans l’histoire. Si vous voyez le codage comme l’art d’écrire des séquences de symboles spéciaux qui ordonnent à un ordinateur de faire des choses spécifiques, alors la composition musicale est une pratique très similaire. Dans la musique occidentale, les symboles sont des points noirs placés sur une portée de lignes qui indiquent au musicien quelles notes jouer et quand. Il est intéressant de noter que si l’on remonte les racines de la notation musicale occidentale jusqu’au moine bénédictin italien Guido d’Arezzo, on constate que le système de points et de lignes utilisé par les orchestres modernes n’est qu’un des nombreux systèmes de notation sur lesquels il a travaillé. Certains des autres systèmes étaient beaucoup plus proches de ce que nous pourrions considérer aujourd’hui comme un code.

Dans le domaine de l’éducation, les expériences magiques et significatives avec les ordinateurs et les langages de programmation ont été explorées depuis la fin des années 60. Les pionniers de l’éducation informatique Seymour Papert, Marvin Minsky et Cynthia Solomon ont exploré des langages simples basés sur le langage Lisp qui permettaient de déplacer des stylos sur de grandes feuilles de papier. Avec quelques commandes simples, il était possible de programmer l’ordinateur pour qu’il dessine n’importe quelle image. Ils ont même expérimenté en étendant leur langage Logo du dessin à la musique. Papert a écrit sur l’apprentissage par l’expérience de la reconstruction du savoir plutôt que de sa transmission. Amener les gens à jouer directement avec les choses était une partie importante du travail de son groupe.

## Performances Sonic Pi

Jylda et Sam Aaron performant à la conférence “the Thinking Digital Conference” dans le “Sage Gateshead”. Crédit photo : TyneSight Photos.

Sonic Pi a été utilisé pour se produire dans un grand nombre de lieux tels que des salles d’école, des boîtes de nuit, sur des scènes extérieures de festivals de musique, des chapelles d’université et des lieux de musique prestigieux. Par exemple, l’étonnant projet Convo qui a réuni 1000 enfants dans le Royal Albert Hall pour interpréter une nouvelle composition ambitieuse de la compositrice Charlotte Harding. La pièce a été écrite pour les instruments traditionnels, les chœurs, les percussions et le code Sonic Pi. L’artiste pop Jylda a également joué avec Sonic Pi dans le Sage Gateshead pour la conférence Thinking Digital, où elle a créé un remix improvisé unique en direct de sa chanson Reeled.

![Sonic Pi dans le Royal Albert Hall](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/convo-small.png Sonic Pi utilisé comme un des instruments pour le Convo au Royal Albert Hall. Crédit photo : Pete Jones.

## Codage en direct en classe

Sonic Pi est un outil de création et de performance musicale basé sur le code qui s’appuie sur toutes ces idées. Contrairement à la majorité des logiciels éducatifs informatiques, il est à la fois assez simple à utiliser pour l’éducation et assez puissant pour les professionnels. Il a été utilisé pour se produire dans des festivals de musique internationaux, pour composer dans des styles variés allant du classique au métal lourd en passant par l’EDM, et a même fait l’objet d’une critique dans le magazine Rolling Stone. Il compte une communauté diversifiée de plus d’un million et demi de codeurs live, aux parcours variés, qui apprennent et partagent tous leurs idées et leurs pensées par le biais du code. Il est libre et gratuit à télécharger pour Mac, PC et Raspberry Pi et comprend un tutoriel convivial qui suppose que vous ne connaissez rien au code ou à la musique.

Sonic Pi a été conçu à l’origine comme une réponse au nouveau programme d’informatique britannique publié en 2014. L’objectif était de trouver une manière motivante et amusante d’enseigner les bases de la programmation. Il s’avère qu’il y a beaucoup de points communs et qu’il est très amusant d’expliquer le séquençage comme une mélodie, l’itération comme un rythme, les conditionnels comme une variété musicale. J’ai développé les concepts initiaux et les premières itérations de la plateforme avec Carrie Anne Philbin, qui a apporté le point de vue d’un enseignant au projet. Depuis lors, Sonic Pi a connu des améliorations itératives grâce au retour d’information obtenu en observant les apprenants et en collaborant directement avec les éducateurs dans la classe. L’une des principales philosophies de conception était de ne jamais ajouter une caractéristique qui ne pourrait pas être facilement enseignée à un enfant de 10 ans. Cela signifiait que la plupart des idées devaient être fortement affinées et retravaillées jusqu’à ce qu’elles soient suffisamment simples. Rendre les choses simples tout en les gardant puissantes reste la partie la plus difficile du projet.

Afin de fournir la motivation magique, la conception de Sonic Pi ne s’est jamais limitée à une pure focalisation sur l’éducation. L’idéal serait que des musiciens et des interprètes célèbres utilisent Sonic Pi comme instrument standard aux côtés des guitares, de la batterie, du chant, des synthés, des violons, etc. Ces interprètes serviraient alors de modèles de motivation démontrant le potentiel créatif du code. Pour que cela soit possible, il a donc fallu consacrer suffisamment d’attention et d’efforts pour en faire un instrument puissant tout en le gardant suffisamment simple pour que des enfants de 10 ans puissent s’en saisir. En plus des éducateurs, j’ai également travaillé directement avec différents artistes dans des classes, des galeries d’art, des studios et des lieux de travail au début du développement de Sonic Pi. Cela m’a permis d’obtenir un retour d’information essentiel qui a permis à Sonic Pi de grandir et, en fin de compte, de s’épanouir en tant qu’outil d’expression créative.

Cette double orientation vers l’éducation et les musiciens professionnels a eu un certain nombre d’effets secondaires passionnants et inattendus. Plusieurs des fonctionnalités sont bénéfiques pour les deux groupes. Par exemple, beaucoup d’efforts ont été déployés pour rendre les messages d’erreur plus conviviaux et utiles (plutôt qu’un énorme fouillis de jargon compliqué). Cela s’avère très utile lorsque vous écrivez un bogue en vous produisant devant des milliers de personnes. De plus, des fonctionnalités telles que la lecture d’échantillons audio de qualité studio, l’ajout d’effets audio, l’accès à l’audio en direct depuis le microphone, tout cela s’avère rendre l’expérience d’apprentissage plus amusante, plus gratifiante et finalement plus significative.

La communauté Sonic Pi continue de s’agrandir et de partager d’étonnantes compositions de code, des plans de cours, des algorithmes musicaux et bien plus encore. La plupart de ces échanges se font sur notre forum amical in_thread (in-thread.sonic-pi.net) qui accueille un groupe très diversifié de personnes comprenant des éducateurs, des musiciens, des programmeurs, des artistes et des fabricants. C’est une véritable joie de voir des gens apprendre à utiliser du code pour s’exprimer de manière nouvelle et inspirer en cela d’autres personnes à faire de même.

# - Quelques capacités amusantes

Du point de vue de l’informatique, Sonic Pi vous fournit les éléments de base pour vous enseigner les notions de base telles qu’elles figurent dans le programme d’études britannique, comme le séquençage, l’itération, les conditionnels, les fonctions, les structures de données, les algorithmes, etc. Toutefois, il s’appuie également sur un certain nombre de concepts importants et pertinents qui ont été adoptés dans l’industrie courante, tels que la concurrence, les événements, la correspondance de modèles, l’informatique distribuée et le déterminisme - tout en gardant les choses suffisamment simples pour les expliquer à un enfant de 10 ans.

Débuter est aussi simple que cela :

    play 70

Une mélodie peut être construite avec une commande supplémentaire, sleep :

    play 70
    sleep 1
    play 72
    sleep 0.5
    play 75

Dans cet exemple, nous jouons la note 70 (environ la 70ème note d’un piano), nous attendons une seconde, nous jouons la note 72, nous attendons une demi-seconde et nous jouons ensuite la note 75. Ce qui est intéressant ici, c’est qu’avec seulement deux commandes, nous avons accès à presque toute la notation occidentale (quelles notes jouer et quand) et les apprenants peuvent coder n’importe quelle mélodie qu’ils ont déjà entendue. Cela conduit à une grande variété de résultats expressifs tout en se concentrant sur le même concept informatique : le séquençage dans ce cas.

En s’inspirant du monde de la musique professionnelle, nous pouvons également reproduire n’importe quel son enregistré. Sonic Pi peut lire n’importe quel fichier audio sur votre ordinateur, mais possède également un certain nombre de sons intégrés pour faciliter la mise en route :

    sample :loop_amen

Ce code permettra de rejouer le break de batterie qui était un pilier du hip-hop des origines, de la drum & bass et de la jungle. Par exemple, un certain nombre d’artistes des débuts du hip-hop ont joué ce break de batterie à mi-vitesse pour lui donner un sentiment plus décontracté :

    sample :loop_amen, rate: 0.5

Dans les années 90, un certain nombre de scènes musicales ont éclaté grâce aux nouvelles technologies qui ont permis aux artistes de démonter des breaks de batteries comme celui-ci et de les remonter dans un ordre différent. Par exemple :

    live_loop :jungle do
     sample :loop_amen, onset: pick
     sleep 0.125
    end

Dans cet exemple, nous introduisons une boucle de base appelée : jungle qui prend un coup de batterie aléatoire dans notre échantillon audio, attend un huitième de seconde et prend ensuite un autre coup de batterie. Il en résulte un flux infini de coups de batterie aléatoires sur lesquels vous pouvez danser tout en découvrant ce qu’est une boucle.

# - Connaissances essentielles

Cette section va couvrir des connaissances très utiles - en vérité essentielles - pour obtenir le meilleur de votre expérience de Sonic Pi.

Nous couvrirons comment prendre avantage des nombreux raccourcis clavier mis à votre disposition, comment partager votre travail et quelques trucs sur l’interprétation musicale avec Sonic Pi.

# - Utilisation des raccourcis

Sonic Pi est tout autant un instrument qu’un environnement de programmation. Les raccourcis peuvent cependant rendre votre jeu avec Sonic Pi plus efficace et naturel - particulièrement quand vous jouez en direct devant un auditoire.

La plus grande part de Sonic Pi peut être contrôlée au moyen du clavier. Au fur et à mesure que vous deviendrez plus familier dans la pratique et l’interprétation avec Sonic Pi, vous commencerez probablement à utiliser de plus en plus de raccourcis. Personnellement, je tape sans regarder le clavier (je recommande que vous appreniez à le faire aussi) et je me sens frustré quand j’ai besoin d’attraper la souris parce que ça me retarde. J’utilise donc tous ces raccourcis très régulièrement !

Par conséquent, si vous apprenez les raccourcis, vous saurez utiliser efficacement votre clavier et vous coderez en direct comme un pro en peu de temps.

Toutefois, n’essayez pas de les apprendre tous à la fois, essayez et souvenez-vous simplement de ceux que vous utilisez le plus et continuez à en ajouter en supplément à votre pratique.

## Compatibilité entre plateformes

Imaginez que vous appreniez la clarinette. Vous vous attendriez à ce que toutes les clarinettes aient les mêmes contrôles et le même doigté. Si elles ne l’avaient pas, vous passeriez un moment pénible à basculer entre différentes clarinettes et vous seriez pris à rester toujours avec la même.

Unfortunately there are a number of standards for shortcuts with macOS and Windows being two of the major styles and other more esoteric editors such as Emacs offering other approaches. You can currently choose between one of these three styles using the menu `IO -> Shortcut Mode`. You can therefore switch between a Windows and a macOS machine and keep your shortcuts consistent.

## “Control” et “Meta”

A key part of the notion of consistency is the naming of shortcuts. In Sonic Pi we use the names Control and Meta to refer to the two main combination keys. On all platforms Control is the same. However, on Linux and Windows, Meta is actually the Alt key while on Mac Meta is the Command key. For consistency we’ll use the term Meta - just remember to map that to the appropriate key on your operating system.

## Abréviations

Pour conserver les choses simples et lisibles, nous utiliserons les abréviations C- pour Control plus une autre touche et M- pour Meta plus une autre touche. Par exemple, si un raccourci consiste à maintenir enfoncées à la fois meta et r, nous l’écrirons M-r. Le - veut dire simplement “en même temps que.”

Voici ci-dessous les raccourcis que j’estime les plus utiles.

## Arrêter et démarrer

Au lieu de toujours attraper la souris pour exécuter votre code, vous pouvez simplement presser `M-r`. Similairement, pour stopper l’exécution de votre code, vous pouvez presser `M-s`.

## Navigation

Je suis vraiment perdu sans les raccourcis de navigation. Je recommande donc vivement que vous passiez du temps à les apprendre. Ces raccourcis fonctionnent aussi extrêmement bien quand vous apprenez à taper sans regarder le clavier parce qu’ils utilisent des lettres standards sans nécessiter de déplacer votre main jusqu’à la souris ou jusqu’aux touches flèches de votre clavier.

For example, if you’re in Emacs Live short cut mode, You can move to the beginning of the line with `C-a`, the end of the line with `C-e`, up a line with `C-p`, down a line with `C-n`, forward a character with `C-f`, and back a character with `C-b`. You can even delete all the characters from the cursor to the end of the line with `C-k`. Other modes will have their own shortcuts which can be easily discovered in the app menu.

## Code ordonné

Pour aligner et indenter automatiquement vos lignes de code, pressez `M-m`.

## Système d’aide

Pour afficher/cacher le système d’aide vous pouvez presser `M-i`. Toutefois, un raccourci plus utile à connaître est `C-i`. Il détecte le mot où se trouve le curseur et affiche la documentation le concernant s’il la trouve. Aide instantanée !

Pour une liste complète, jetez un œil à la section B.2 - Antisèche des raccourcis.

# - Antisèche des raccourcis

The following is a summary of the main Emacs Live shortcuts available within Sonic Pi. Please see Section B.1 for motivation and background.

## Conventions

Dans cette liste, nous utilisons les conventions suivantes (où Meta est la touche Alt pour Windows/Linux et Cmd sur Mac) :

- `C-a` signifie maintenir la touche Control enfoncée puis presser la touche a en les maintenant les deux en même temps, puis les relâcher.
- `M-r` signifie maintenir la touche Meta enfoncée puis presser la touche r en les maintenant les deux en même temps, puis les relâcher.
- `S-M-z` signifie maintenir les touches Majuscule et Meta enfoncées puis presser la touche z en les maintenant les deux en même temps, puis les relâcher.
- `C-M-f` signifie maintenir les touches Control et Meta enfoncées puis presser la touche f en les maintenant les deux en même temps, puis les relâcher.

## Manipulation de l’application principale

- `M-r` - Exécute le code
- `M-s` - Arrête le code
- `M-i` - Affiche/cache le système d’aide
- `M-p` - Affiche/cache les préférences
- `M-{` - Bascule sur le buffer de gauche
- `M-}` - Bascule sur le buffer de droite
- `S-M-0` - Bascule vers le tampon 0
- `S-M-1` - Bascule vers le tampon 1
- …
- `S-M-9` - Bascule vers le tampon 9
- `M-+` - Augmente la taille du texte du buffer courant
- `M--` - Diminue la taille du texte du buffer courant

## Sélection/Copier/Coller

- `M-a` - Sélectionner tout
- `M-c` - Copie la sélection dans le presse-papier
- `M-]` - Copie la sélection dans le presse-papier
- `M-x` - Coupe la sélection et la copie dans le presse-papier
- `C-]` - Coupe la sélection et la copie dans le presse-papier
- `C-k` - Coupe jusqu’à la fin de la ligne et le copie dans le presse-papier
- `M-v` - Colle depuis le presse-papier
- `C-y` - Colle depuis le presse-papier
- `C-SPACE` - Pose une marque. La navigation surligne et sélectionne la région depuis la marque. Utilisez `C-g` pour sortir.

## Manipulation du texte

- `M-m` - Aligne et indente tout le texte
- `Tab` - Aligne et indente la ligne courante ou la sélection (ou sélectionne l’auto-complétion)
- `C-l` - Centre l’éditeur
- `M-/` - Commente/Décommente la ligne courante ou la sélection
- `C-t` - Intervertit les caractères sélectionnés
- `M-u` - Convertit le mot suivant (ou la sélection) en majuscule.
- `M-l` - Convertit le mot suivant (ou la sélection) en minuscule.

## Navigation

- `C-a` - Déplace au début de la ligne
- `C-e` - Déplace à la fin de la ligne
- `C-p` - Déplace à la ligne précédente
- `C-n` - Déplace à la ligne suivante
- `C-f` - Avance d’un caractère
- `C-b` - Recule d’un caractère
- `M-f` - Avance d’un mot
- `M-b` - Recule d’un mot
- `C-M-n` - Déplace la ligne ou la sélection vers le bas
- `C-M-p` - Déplace la ligne ou la sélection vers le haut
- `S-M-u` - Déplace 10 lignes vers le haut
- `S-M-d` - Déplace 10 lignes vers le bas
- `M-<` - Aller au début du tampon
- `M->` - Aller à la fin du tampon

## Suppression

- `C-h` - Supprime le caractère précédent
- `C-d` - Supprime le caractère suivant

## Fonctionnalités avancées de l’éditeur

- `C-i` - Affiche la documentation du mot où se trouve le curseur
- `M-z` - Défait
- `S-M-z` - Refait
- `C-g` - Sortir
- `S-M-f` - Bascule en mode plein écran
- `S-M-b` - Affiche/cache les boutons
- `S-M-l` - Affiche/cache le panneau “trace”
- `S-M-m` - Bascule entre l’affichage clair et sombre
- `S-M-s` - Enregistrer le contenu du tampon dans un fichier
- `S-M-o` - Charger le contenu d’un tampon à partir d’un fichier

# - Partage

Sonic Pi a tout ce qu’il faut pour partager et apprendre avec les autres.

Une fois que vous avez appris comment coder de la musique, partager vos compositions est aussi simple que d’envoyer un courriel contenant votre code. SVP partagez votre code avec les autres, ainsi ils pourront apprendre de votre travail et même en utiliser des parties dans un nouveau “mashup”.

Si vous n’êtes pas sûr de connaître le meilleur moyen de partager votre travail avec les autres, je vous recommande de mettre votre code sur GitHub et votre musique sur SoundCloud. De cette manière vous pourrez atteindre facilement un grand auditoire.

## Code -> GitHub

GitHub est un site pour partager et travailler avec du code. Il est utilisé aussi bien par des développeurs professionnels que par des artistes pour partager et collaborer avec du code. La manière la plus simple pour partager un morceau de code (ou même un morceau non terminé) est de créer un Gist. Un Gist est un moyen simple de déposer votre code afin que les autres y aient accès de manière simple : voir, copier et partager.

## Audio -> SoundCloud

Une autre façon importante de partager votre travail est d’enregistrer l’audio et de déposer l’enregistrement sur SoundCloud. Une fois que vous avez déposé votre morceau, les autres peuvent commenter et discuter de votre travail. Je vous recommande aussi de placer un lien vers le Gist de votre code dans la description de la piste.

Pour enregistrer votre travail, pressez le bouton `Rec` de la barre d’outils, et l’enregistrement démarre immédiatement. Pressez `Run` pour lancer votre code s’il n’est pas encore démarré. Quand votre enregistrement devra être arrêté, pressez le bouton `Rec` clignotant à nouveau, et il vous sera demandé d’entrer un nom de fichier. L’enregistrement sera sauvegardé dans le format d’un fichier WAV, lequel peut être modifié et converti en MP3 par n’importe quel programme gratuit (essayez Audacity par exemple).

## Espoir

Je vous encourage à partager votre travail et j’espère vraiment que nous allons tous nous apprendre de nouvelles astuces et progresser avec Sonic Pi. Je suis très enthousiaste de ce que vous allez avoir à me montrer.

# - Se produire

Un des aspects les plus passionnants de Sonic Pi est qu’il vous permet d’utiliser le code comme un instrument de musique. Cela signifie qu’écrire du code en direct peut maintenant être considéré comme une nouvelle manière d’interpréter de la musique.

Nous appelons ceci codage en direct.

## Montrez votre écran

Quand vous codez en direct, je vous recommande de montrer votre écran à votre auditoire. Autrement, c’est comme jouer de la guitare, mais en cachant vos doigts et les cordes. Quand je pratique à la maison, j’utilise un Raspberry Pi et un mini projecteur sur le mur de mon salon. Vous pouvez utiliser votre TV ou l’un de vos projecteurs d’école/travail pour faire un spectacle. Essayez-le, c’est beaucoup de plaisir.

## Formez un groupe

Ne vous contentez pas de jouer seul - formez un groupe de codage en direct ! C’est très amusant de jouer avec d’autres. Une personne peut faire des beats, une autre des ambiances de fond, etc. Utilisez la fonctionnalité `live_audio` pour combiner le code avec des instruments traditionnels tels qu’une guitare ou un microphone.

Voyez quelles combinaisons de sons intéressantes vous pouvez créer avec du code.

## TOPLAP

Le codage en direct n’est pas totalement nouveau - un petit nombre de personnes le font maintenant depuis quelques années, typiquement en utilisant des systèmes sur mesure qu’ils avaient élaborés eux-mêmes. Un super site à visiter pour trouver plus d’informations sur les autres codeurs en direct et leurs systèmes est TOPLAP.

## Algorave

Une autre bonne ressource pour explorer le monde du codage en direct est Algorave. Vous trouverez là tout sur une branche spécifique du codage en direct pour faire de la musique dans les boîtes de nuit.