# 1 - Welkom vriend :-)

Welkom bij Sonic Pi. Hopelijk ben je net zo enthousiast als ik om te gekke klanken te gaan maken. Het zal een leuk avontuur worden, waarin je alles over muziek, synthese, programmeren, compositie en ook live spelen gaat leren en nog veel meer…

Maar wacht,dat was onbeleefd van mij! Ik moet mij nog voorstellen. Ik ben [Sam Aaron] ( http://twitter.com/samaaron ) de kerel die Sonic Pi creëerde. Je vind mij als @samaaron op Twitter en ik zal heel blij zijn om je daar te kunnen begroeten. Misschien ben je ook geïnteresseerd om meer te weten te komen over mijn [Live Coding Performances] (https://youtube.com/samaaron) waar ik, voor publiek, live codeer met Sonic Pi.

Mocht je gedachten of ideeën hebben om Sonic Pi te verbeteren, aarzel dan niet om deze door te geven; terugkoppeling is zo nuttig. En, je weet het nooit, jouw idee zou de volgende grote nieuwe functie kunnen zijn!

Deze handleiding is verdeeld in secties en gegroepeerd per categorie. Hoewel ik deze in een volgorde geschreven heb met een eenvoudige leercurve voor ogen, wees vrij, om in afzonderlijke secties te duiken zoals jij dat wil. Als je het gevoel hebt dat er iets ontbreekt, laat dit gerust aan mij weten, ik zal jouw bedenking in overweging nemen voor een toekomstige versie.

Tenslotte, anderen live code te zien doen, is een fantastische manier om het te leren. Regelmatig stream ik live op http://youtube.com/samaaron ga daar eens kijken, om een Hallo! te zeggen of vragen te stellen :-)

OK, laten we beginnen…

# 1.1 - Live Coderen

Een van de meest opwindende aspecten van Sonic Pi is, dat het je in staat stelt, code te gaan schrijven en de code, ook live te wijzigen om muziek te spelen, net zoals je live gitaar zou spelen. Dit betekent dat je, mits wat oefening, met Sonic Pi het podium op kan en hiermee kan optreden.

## Maak je hoofd leeg

Voor we in detail gaan over hoe Sonic Pi werkt, verderop in deze handleiding, wil ik je even de ervaring meegeven, hoe het voelt om live te coderen. Maak je geen zorgen als je hier niet veel (of niets) van begrijpt. Blijf gewoon even zitten en geniet …

## Een loop “live” brengen

We gaan van start, kopieer de volgende code in een lege buffer hierboven:

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

Klik nu op de `afspeel` knop en je zal een lekkere snelle basdrum horen vertrekken. Je kan nu, wanneer jij dat wenst, het geluid stoppen door op de `Stop`’ knop te klikken. Maar doe dat nog even niet… neem in plaats daarvan de volgende stappen:

Zorg ervoor dat deze basdrum klank nog steeds loopt Verander de waarde van ‘sleep’ van ‘0.5’ naar een ietwat hoger getal,zoals bv. `1`. Klik opnieuw op de `afspeelknop` Merk op dat de snelheid van de drum hierbij veranderd is. En onthou dit moment, dit is de eerste keer dat je een Live Code met Sonic Pi hebt gedaan en het is waarschijnlijk niet je laatste keer…

Ok, dat was eenvoudig. We gaan er nog iets aan de mix toevoegen. Boven `sample :bd_haus` voeg je deze lijn toe `sample :ambi_choir, rate: 0.3`. Jouw code moet er nu als volgt uitzien:

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

Speel hiermee. Verander de `rate:` (snelheid) waardes - wat gebeurd er, als je hoge waarden gebruikt,of kleine waarden of negatieve waarden? Kijk wat er gebeurd wanneer je de `rate:` waarde van het `:ambi_choir` sample maar een tikkeltje veranderd (bv. 0.29). Wat gebeurd er als je een héél kleine `sleep` (rust) waarde kiest? Kijk nu of je het zo snel kan laten gaan dat je computer stopt en een foutmelding geeft omdat hij het niet meer kan verwerken (wanneer dit gebeurd, kun je gewoon een grotere `sleep` tijd instellen en op `afspelen` klikken).

Probeer één van de `sample` lijnen van een commentaar te voorzien door er een `#` voor te zetten:

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

Merk op hoe het de computer opdraagt deze lijn te negeren, zodat we deze niet horen. Dit heet een comment (commentaarlijn). In Sonic Pi kunnen we een commentaarlijn gebruiken om klanken uit de mix te verwijderen of toe te voegen.

Ik laat je nu even met het volgende spelen. Neem de onderstaande code, en kopieer deze in een lege buffer. Probeer er nu nog niet al te veel van te begrijpen, maar wel in te zien dat er twee loops zijn - dus twee klanken die op het zelfde moment spelen. Het beste wat je kan doen nu is, experimenteren en er, gewoon op los, mee te gaan spelen. Hier zijn enkele suggesties:

Wijzig de blauwe `rate:` waarden, om het geluid van de sample-klank te horen veranderen. Wijzig de `sleep` tijd en hoor nu, dat je beide loops kunt afspelen met verschillende rusttijden. Probeer de commentaarlijn te wissen (verwijder het `#`) uit onze voorbeeldlijn en geniet van de gitaarklank, die nu achterwaarts afspeelt. Probeer de blauwe `mix:` waarden te veranderen naar cijfers tussen `0` (niet in de mix) en `1` (voluit in de mix).

Denk er ook aan, te klikken op ‘afspelen’ om deze veranderingen te kunnen horen, bij de volgende loop die vertrekt. Maak je geen zorgen als het hierbij soms in de soep draait, klik dan op `Stop`, wis de code in de buffer en plak er een nieuwe kopie in, zo je bent weer gereed om opnieuw te gaan improviseren. Van je fouten kan je nu eenmaal het beste leren.

    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

Blijf nu spelen en experimenteren tot je de nieuwsgierigheid begint te voelen en je je begint af te vragen wat je hier nog allemaal mee kan doen. Dan ben je nu klaar om de rest van de handleiding te lezen.

Dus,waar wacht je nog op . . .

# 1.2 - De Interface van Sonic Pi

Sonic Pi heeft een zeer eenvoudige interface om muziek te coderen. Laten we hier eens wat tijd aan besteden om deze te verkennen.

A - Afspeel knoppen B - Editor aanpassen C - Info en Hulp D - Code Editor E - Paneel Voorkeursinstellingen F - Log Venster G - Hulp-Systeem H - Scope Venster

## A. Afspeel knoppen

Deze roze knoppen zijn de belangrijkste bedieningselementen voor het starten en stoppen van het geluid. Er is de Afspelen knop om de code in de editor af te spelen, Stop om alle actieve code te stoppen, opslaan om de code naar een extern bestand op te slaan en Opnemen om een opname (WAV-bestand) te maken van het afgespeelde geluid.

## B. Controle over de Editor

These orange buttons allow you to manipulate the code editor. The Size + and Size - buttons allow you to make the text bigger and smaller.

## C. Info and Hulp

Deze blauwe knoppen geven je toegang tot hulp-, informatie- en voorkeursinstellingen. De Info knop opent het venster die informatie over Sonic Pi zelf bevat - het kernteam, de geschiedenis, de medewerkers en ook de Sonic Pi “gemeenschap”. De Hulp knop schakelt naar het hulp-systeem (G) en de Voorkeuren knop schakelt naar het voorkeur-venster waarmee u een aantal fundamentele systeemparameters kan bijsturen.

## D. Code Editor

Dit is het gebied waarin je jouw code schrijft en muziek componeert/uitvoert. Het is een eenvoudige tekst-editor, waarin je code kan schrijven, verwijderen, knippen en plakken, enz. Denk aan een zeer eenvoudige versie van Word of Google Docs. De editor zal de kleur van woorden automatisch aanpassen op basis van hun betekenis in de code. Dit lijkt misschien eerst wat vreemd, maar je zal dit snel heel nuttig vinden. Bijvoorbeeld als het het blauw ziet, dan weet je dat het om een getal gaat.

## E. Paneel Voorkeursinstellingen

Sonic Pi ondersteunt een aantal instellingen die toegankelijk zijn door het in-/uitschakelen van de knop Voorkeuren in de Info en Hulp knoppen-set. Dit zal de zichtbaarheid van het Paneel Voorkeursinstellingen, met daarin een aantal regelbare opties, in- of uitschakelen. Voorbeelden zijn: het brengen van stereo naar mono, stereo omkeren, de detaillering van het log en ook een volumeregelaar en audio keuze voor de Raspberry Pi.

## F. Log Venster

Wanneer je je code uitvoert,zal informatie over wat het programma doet, getoond worden in een soort logboek. Standaard zal je een berichtje zien, voor elk geluid dat je maakt, met de exacte tijd dat het geluid werd geactiveerd. Dit is zeer handig om fouten in je code op te kunnen sporen en om te kunnen begrijpen wat je code doet.

## G. Hulp Systeem

Eén van de belangrijkste onderdelen van de Sonic Pi-interface is het hulp-systeem dat wordt weergegeven aan de onderkant van het venster. Dit kan worden in- en uitgeschakeld door op de blauwe knop Hulp te klikken. Het hulp-systeem bevat hulp en informatie over alle aspecten van Sonic Pi, inclusief deze handleiding, een lijst van beschikbare synths, samples, voorbeelden, effecten en een volledige lijst van alle functies die Sonic Pi biedt voor het coderen van muziek.

## H. Scope Venster

Met het scope venster zie je het geluid. Je ziet hier dat een zaagtand-golf er ook uitziet als een zaag en dat onze basis biep-toon een mooie golvende sinus-golf is. Je ziet ook duidelijk het verschil tussen luide en zachte klanken door hun grootte. Er zijn 3 verschillende scopes beschikbaar- de standaard (default) is een gecombineerde scope voor het linker en rechter kanaal, een stereo die voor elk kanaal een aparte scope laat zien. En tenslotte is er een Lissajousfiguur scope die de relatie in fase tussen het linker- en rechter-kanaal weergeven en die je in staat stelt, mooie figuren te tekenen met geluid (https://nl.wikipedia.org/wiki/Lissajousfiguur).

# 1.3 - Spelenderwijs Leren

Sonic Pi moedigt je aan om meer te gaan leren over zowel de computer als over muziek door middel van spel en experimenteren. Het belangrijkste is dat je hierin plezier hebt, en voor je het beseft, heb je hierdoor geleerd, hoe te coderen, te componeren en live te spelen.

## Er bestaan geen fouten

Nu we er toch over bezig zijn, geef ik je graag een raad mee, wat ik heb geleerd in de jaren van live muziek coderen is - er bestaan geen fouten, alleen kansen. Dit is iets wat ik vaak heb horen zeggen over jazz, maar het werkt even goed met live codering. Ongeacht hoe ervaren je bent - van een complete beginner tot een doorgewinterde Algoraver, je zal soms code uitvoeren met een geheel onverwacht resultaat. Het kan waanzinnig cool klinken- in dat geval komen we er mee weg. Het kan ook compleet dwaas en ontoepasselijk klinken. Maar het maakt niet uit dat het gebeurd is - waar het om gaat is, wat je er vervolgens mee doet. Pak de klank, manipuleer deze en morph het naar iets ongeloofelijk. Je publiek zal uit de bol gaan.

## Start Eenvoudig

Wanneer je aan het leren bent, is het verleidelijk om nu al verbazingwekkende dingen te gaan doen. Maar het is beter om die wens vast te houden en als een toekomstig doel voor ogen te houden om later te bereiken. Probeer kleine, eenvoudige stappen te zetten en te zien hoe dit jou plezier geeft en je dichter tot je doel brengen. Eens je de kleine stappen onder de knie hebt, kan je deze als bouwstenen gebruiken en hiermee spelen, en je zal zien dat deze nieuwe inzichten, jou ook verse ideeën zullen geven. Snel genoeg ben je fijn bezig én maak je vooruitgang.

Zorg ervoor dat je je werk deelt met anderen!

# 2 - Synthesizers

OK, genoeg intro’s - laat ons in enkele klanken duiken.

In deze sectie zullen we de basisprincipes van het triggeren en het manipuleren van synth’s behandelen. Synth is kort voor synthesizer, wat een chique woord is voor een ding dat geluiden kan creëren. Synth’s zijn doorgaans vrij ingewikkeld om te gebruiken - met name analoge synth’s met vele patch kabels en modules. Sonic Pi biedt je een zelfde kracht op een eenvoudige en toegankelijke wijze.

Laat je niet misleiden door de directe eenvoud van de Sonic Pi interface. Je kunt hier diepgaand, in zeer geavanceerde geluidsmanipulatie gaan als dat je ding mocht zijn. Hou je maar vast…

# 2.1 - Je Eerste Bliepjes

Bestudeer de volgende code:

    play 70

Dit is waar het allemaal begint. Ga je gang, kopieer en plak deze in het codevenster aan de bovenzijde van de app (de grote witte ruimte onder de Afspeel knop). Nu, klik op Afspelen…

## Bliep!

Heftig. Klik opnieuw. En opnieuw. En opnieuw…

Woah, te gek, ik weet zeker dat je dit een hele dag kan blijven doen. Maar wacht, voordat je jezelf verliest in een oneindige stroom van bliepjes, probeer het cijfer te wijzigen:

    play 75

Hoor je het verschil? Probeer een lager cijfer:

    play 60

So, lower numbers make lower pitched beeps and higher numbers make higher pitched beeps. Just like on a piano, the keys at the lower part of the piano (the left hand side) play lower notes and the keys on the higher part of the piano (the right hand side) play higher notes.

play 60

Maak je geen zorgen wanneer dit niets voor jou betekent, mij betekende het ook niets toen ik er eerst aan begon. Het belangrijkste is dat je weet dat lage getallen, lagere tonen maken en hoge getallen, hogere tonen.

## Akkoorden

Een noot spelen kan leuk zijn, maar veel noten op het zelfde moment spelen kan het beter maken. Probeer dit:

    play 72
    play 75
    play 79

Jazzy! Dus, als je meerdere „play”s typt, spelen ze allemaal op hetzelfde moment. Probeer het voor jezelf - welke cijfers klinken goed samen? En welke verschrikkelijk samen? Experimenteer, verken en ontdek dit voor jezelf.

## Melodie

Zo, het spelen van noten en akkoorden is leuk, maar hoe zit dat met een melodie? Wat als je noten achter elkaar wil spelen en niet op dezelfde moment? Wel dat is eenvoudig, je moet enkel een rust („sleep”) zetten tussen de noten:

    play 72
    sleep 1
    play 75
    sleep 1
    play 79

Hoe mooi, zo een beetje arpeggio. Dus wat betekent de ‘1’ in ‘sleep 1’? Nou het betekent de duur van de rust. Het betekent eigenlijk slaap voor één tel , voor 1 seconde rusten. Dus, wat als we onze arpeggio een beetje sneller willen? Nou, dan moeten we kortere slaap waarde gebruiken. Wat denk je van de helft? D.w.z. ‘0.5’:

    lay 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

Merk op hoe het sneller speelt. Probeer dit nu voor jezelf, verander de rusttijd- gebruik verschillende tijden en noten.

Wat je zeker ook kan proberen is om “tussen” noten te spelen zoals `play 52.3` and `play 52.63`. Het is absoluut niet noodzakelijk om te blijven vasthouden aan standaard „hele” noten. Speel erop los en amuseer je.

## Traditionele Notennamen

Als je al kennis hebt van muzieknotatie (maak je geen zorgen als dit niet het geval is, zonder deze kennis blijft het even leuk), dan wil je bij het schrijven van een melodie, misschien liever de nootnamen gebruiken zoals: C en F# in plaats van cijfers. In Sonic Pi kan je dat. Je kan dan het volgende doen:

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

Denk eraan, een dubbelpunt voor de nootnaam te plaatsen, zodat deze in roze wordt. Je kan hierbij ook het octaaf aangeven door achter de nootnaam een cijfer te plaatsen:

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

Als je een verhoogde alteratie (bv. F#) zet je een ‘s’ achter de nootnaam, bv. `play :Fs3`. Als je een verlaagde alteratie wil maken (bv. E mol), zet dan een ‘b’ achter de nootnaam bv. `play :Eb3`.

Ga nu maar lekker loos bij het maken van je eigen melodietjes, veel plezier ermee.

# 2.2 - Synthesizer Opties: Amp en Pan

Zoals je kan bepalen welke noot er gespeeld wordt of welke sample er wordt getriggert, zo biedt Sonic Pi een hele waaier aan mogelijkheden om geluiden te bewerken en manipuleren. We gaan velen daarvan in deze handleiding bekijken en in het hulp systeem is een uitgebreide documentatie voorzien van deze ‘opties’. De belangrijkste op dit moment zijn: ‘amplitude’ en ‘pan’. Laat ons eerst even bekijken wat opties eigenlijk zijn.

## Opties

Sonic Pi ondersteunt het noteren van opties (afgekort: opts) voor haar synths. Opts zijn controle-elementen die je samen met het commando ‘play’ doorgeeft die wijzigingen en manipulaties van het afgespeelde geluid. Elke synth heeft zijn eigen unieke set van opts om haar geluid fijn af te stemmen. Er zijn echter opts die bij elke synth, of bij elk geluid gebruikt kunnen worden zoals ‘amp:’ en ‘envelope’ (= geluidsverloop) opties (In een andere sectie gaan we dieper op die ‘envelopes’ in).

Opts bestaan uit twee belangrijke delen (de naam van het element waar je controle over wil hebben) en de waarde hiervan (de mate van controle over dit element). Een voorbeeld, je hebt een opt genaamd ‘kaas’ en je wilt deze instellen op een waarde van ‘1’.

Opts worden samen met ‘play’ commando’s doorgegeven, dor gebruik te maken van een komma ‘,’ gevolgd door de naam van de optie, we kiezen hier ‘amp:’ (vergeet de dubbelpunt niet ‘:’ ) gevolgd door een spatie en de waarde van de optie. Bijvoorbeeld:

    play 50, kaas: 1

(Merk op dat ‘ kaas: “geen geldige opt is, we gebruiken deze gewoon als voorbeeld).

Je kan meerdere opts tegelijk doorgeven door deze te scheiden met een komma:

    play 50, kaas: 1, eieren: 0.5

De volgorde van de opts maakt niet uit, dus het volgende is identiek:

    play 50, eieren: 0.5, kaas: 1

Opts die door de synth niet worden herkent zullen gewoon genegeerd worden (zoals ‘kaas’ en ‘eieren’ duidelijk zeer ridicule opt namen!)

Mocht je per ongeluk twee keer dezelfde opt hebben ingevoerd maar met verschillende waarden, dan zal de laatste waarde winnen. Bijvoorbeeld, ‘eieren’ zal de waarde 2 hebben in plaats van 0.5:

    play 50, eieren: 0.5, kaas: 3, tomaat: 0.1, eieren: 2

Opts worden door veel items in Sonic Pi geaccepteerd, dus probeer deze onder de knie te krijgen, het loont echt! Laten we wat spelen met onze eerste opt: `amp:`.

## Amplitude

Amplitude is de representatie van het geluidsvolume op een computer. Een hoge amplitude produceert het geluid op een luid volume en een lage amplitude op een zacht volume. Net zoals Sonic Pi cijfers gebruikt om noten en tijden aan te geven, gebruikt het cijfers om amplitude te bepalen. Een amplitude van ‘0’ is stil (je zal niets horen) en een amplitude van ‘1’ is een normaal volume. Je kan het volume zelfs nog opdrijven en verhogen tot 2, 10, 100. Maar u moet er wel rekening mee houden dat wanneer het globale volume te hoog wordt, zal Sonic Pi een compressie inschakelen en het geluid onderdrukken om ervoor te zorgen dat je oren gespaard blijven. Dit kan het geluid dan weer dof en vreemd doen laten klinken. Dus is het beter lage amplitudes te gebruiken, dwz. tussen 0 tot0.5 om compressie te vermijden.

## Amp ‘t op

Om de amplitude van een geluid te veranderen, kan je de ‘amp:’ optie gebruiken. Bijvoorbeeld, op gemiddelde amplitude afspelen, gebruik dan 0.5:

    play 60, amp: 0.5

Afspelen op dubbel zo hoge amplitude gebruik 2:

    play 60, amp: 2

De amp opt verandert enkel de ‘play’ oproep waarmee deze wordt geassocieerd. In dit voorbeeld zal de eerste oproep dus aan de helft van het volume spelen en de tweede op standaard-instelling (1):

    play 60, amp: 0.5
    sleep 0.5
    play 65

Natuurlijk kunnen verschillende ‘amp:’ waarden per ‘play’ oproep worden gebruikt:

    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

## Pannen

Een ander leuke opt om te gebruiken is ‘pan:’ die bepaalt de panning van een geluid in stereo. Naar links pannen betekent dat je het geluid door de linker-luidspreker hoort, naar rechts pannen betekent dat je het geluid door de rechter-luidspreker hoort. Onze cijferwaarde -1 betekend helemaal links, 0 geeft het midden weer en 1 geeft helemaal rechts van ons stereobeeld. Natuurlijk zijn we vrij om elke waarde tussen -1 en 1 te gebruiken om de exacte positie van ons geluid te bepalen.

Laten we eens een bliepje uit de linkerluidspreker doen klinken:

    play 60, pan: -1

En nu uit de rechter luidspreker:

    play 60, pan: 1

En nu terug vanuit beiden samen (standaard positie):

    play 60, pan: 0

Doe nu maar, en veel plezier met het veranderen van de amplitude en het pannen van uw geluiden!

# 2.3 - Synths Veranderen

Tot nu hebben we al heel wat plezier beleeft met onze biepjes. Dit standaard biepje zal ons echter na een tijdje gaan vervelen. Is het dit alles wat Sonic Pi ons te bieden heeft? Er moet toch meer kunnen dan alleen maar wat biepjes maken met dit hele gedoe van live-coderen? Oh ja zeker, en in deze sectie gaan we de spannende serie klanken die Sonic Pi te bieden heeft verkennen.

## Synthesizers

Sonic Pi heeft een waaier aan instrumenten, synths genaamd -dat is de verkorting van synthesizers. Waar samples reeds opgenomen klanken vertegenwoordigen, zijn synths in staat om nieuwe klanken te genereren, afhankelijk van hoe je deze instelt (dat gaan we later in deze handleiding ontdekken). Sonic Pi’s synths zijn heel krachtig en expressief en je zal er een veel plezier aan beleven deze te leren kenen en te bespelen. Maar eerst gaan we leren hoe we deze kunnen selecteren.

## Drukke Zaagtand-golven en “Prophets”

Een leuke klank is de zaagtand-golf, laten we deze uitproberen:

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

Laten we nog een andere klank proberen, de prophet:

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

Hoe zit het dan met het combineren van twee verschillende klanken? Eerst de ene na de andere:

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

Now multiple sounds at the same time (by not sleeping between successive calls to `play`):

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

Merk hierbij op dat het `use_synth` commando, alleen invloed heeft op de daarop volgende oproepen van ‘play’. Stel je deze even voor,als een grote schakelaar, die bij nieuwe ‘play’ opvragingen, eender welke synth laat afspelen waar momenteel naar verwezen wordt. Je kan die dan omschakelen naar andere synth door het gebruik van `use_synth`.

## Synths Ontdekken

Om te zien welke synths Sonic Pi voor u heeft om mee te spelen neem dan een kijkje op de Synths-opties in het uiterst links verticale menu (boven Effecten). Er zijn er meer dan 20 om uit te kiezen. Hier zijn een paar van mijn favorieten:

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

Speel nu een beetje met dit schakelen van synths terwijl je muziekstuk afspeelt. Veel plezier met het combineren van synths om nieuwe klanken te maken of om verschillende secties in uw muziekstuk van verschillende synths te voorzien.

# 2.4 - Geluidsduur met “Envelopes”

In een eerdere sectie, hebben we gezien hoe we de opdracht ‘sleep’ gebruiken om te bepalen wanneer we onze geluiden activeren . We zijn echter nog in staat geweest om te bepalen hoe lang onze klank duurt.

Om ons een eenvoudig maar krachtig middel te geven waar we de controle hebben over de tijdsduur van onze klank, biedt Sonic Pi ons een zekere manier van notering van een zogenaamde ADSR amplitude envelope (we bespreken later in deze sectie wat dat betekent). Een amplitude “envelope” biedt twee manieren van controle:

controle over de duurtijd van een klank controle over de amplitude van een klank

## Duurtijd

De duurtijd is de lengte dat een klank aanhoud . Een langere duur betekent dat u de klank langer hoort. De klanken van Sonic Pi hebben allen een instelbare amplitude envelop, de totale duur van die envelop is dan de totale duurtijd van die klank. Daarom kan je, door het instellen van de envelop, de duurtijd bepalen.

## Amplitude

De ADSR envelop regelt niet alleen de duurtijd, het geeft je ook een fijnregeling van de geluidssterkte van de klank. Alle hoorbare klanken starten en eindigen van en naar onhoorbaarheid en bevatten, tussendoor, luidere en minder luide delen. De ASDR envelop staat je toe de geluidssterkte van de hoorbare gedeelten van een klank te verschuiven en vast te houden. Zoals je iemand instructies zou geven aan het volume van een gitaarversterker en deze van stil, naar langzaam omhoog tot het hoogste volume en deze even aan te laten houden, om deze dan, snel of traag, terug naar stil te brengen. Door de envelop kan je dit gedrag in Sonic Pi programmeren.

Even recapituleren, zoals we eerder hebben gezien, is een amplitude van 0 is stilte en een amplitude van 1 is het normale volume.

Laten we nu kijken naar elk onderdeel van de envelop.

## Release fase

Het enige deel van de envelop die standaard wordt gebruikt is de release tijd. Dit is de tijd die nodig is om het geluid van een synth uit te vervagen. Alle synthesizers hebben een release tijd van 1, wat betekent dat ze standaard een duur van 1 beat hebben (en dus op onze standaard 60 BPM, 1 seconde lang is):

    play 70

De noot zal 1 seconde lang hoorbaar zijn. Chronometreer maar :-) Dit is de verkorting van de langere, meer uitgesproken versie:

    play 70, release: 1

Merk op dat deze exact hetzelfde klinkt (de klank duurt één seconde). Het is dus heel makkelijk om de duurtijd in te stellen door de waarde te veranderen van de `release:` optie:

    play 60, release: 2

We kunnen de synth voor een heel korte tijd laten klinken door een heel korte release tijd te gebruiken:

    play 60, release: 0.2

De duur van het “vrijlaten” van het geluid noemen we de release fase en staat standaard op een lineaire overgang ingesteld (dwz rechtlijnig).Het volgende diagram illustreert deze overgang:

De verticale lijn aan de linkerkant van het diagram toont ons dat het geluid bij amplitude 0 begint, onmiddellijk klimt naar volledige amplitude (dit is de aanslag fase, die zullen we vervolgens bespreken). Eens bij volledige amplitude gaat het in een rechte lijn naar nul zakken in de tijd die is opgegeven met `release:`. Langere release tijden leveren een langer verloop, waarmee het geluid van de synth uitvaagt, op

Je kan dus de duurtijd van je klank veranderen aan de hand van de release tijd. Speel hier even mee, door deze release tijden toe te voegen aan je klanken.

## Aanslag fase (de Attack)

De aanslag fase is voor alle synths standaard ingesteld op 0, wat betekend dat deze onmiddellijk van 0 naar 1 gaat. Dit geeft aan de synth een korte hevige klank zoals bij een percussie-instrument. Maar misschien wil je je geluid zachtjes luider laten worden. Dit kunnen we met de `attack:` optie. Probeer nu eens van klanken te laten aanzwellen:

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

Je kan meerdere opties tegelijk kiezen. Probeer deze bijvoorbeeld voor een kortere aanslag en een langere uitloop:

    play 60, attack: 0.7, release: 4

Deze korte attack en lange release envelop wordt geïllustreerd in het volgende diagram:

Natuurlijk, kan je de dingen omdraaien. Probeer een lange attack en een korte release:

    play 60, attack: 4, release: 0.7

Voorts kan je ook korte Attack en release tijden hebben voor korte klanken.

    play 60, attack: 0.5, release: 0.5

## SustainFase

Naast het opgeven van attack en release tijden, u kunt ook een sustain-tijd opgeven om de sustain fase in te stellen. Dit is de tijd dat het geluid bij een volledige amplitude tussen de attack en de release fase wordt gehandhaafd.

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

De sustain-tijd is nuttig voor de klanken die je een volledige tegenwoordigheid in de mix wil geven voordat deze een release fase doorlopen. Natuurlijk, is het volkomen geldig om zowel de `attack:` als de `release:` optie in te stellen op 0, om gewoon geen fade in- of fade out aan het geluid toe te voegen. Maar hier moet je mee opletten, een release van 0 kan klikjes in de audio produceren en het is vaak beter om een zeer kleine waarde te gebruiken zoals 0,2.

## Verval fase (Decay Phase)

Voor een extra controle niveau kunt u ook de verval tijd instellen. Dit is de fase van de envelop die past tussen de attack en sustain fasen en geeft u een tijdwaarde waarbij de amplitude zal dalen het `attack_niveau:` naar het `decay_niveau:` (die, tenzij u die expliciet instelt, op het ‘ sustain_niveau:’ gebracht zal worden). Standaard, is de `decay:` optie 0 en hebben zowel attack en sustain niveaus zijn 1, deze zal je dus moeten opgeven voor de verval tijd effect heeft:

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

## Verval niveau

Eén laatste truc is dat, hoewel de `decay_level:` optie standaard dezelfde waarde heeft ingesteld als `sustain_level:`, je deze wel expliciet kan instellen op verschillende waarden voor de volledige controle over de envelop. Hierdoor kan je een envelop maken zoals deze:

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

Het is ook mogelijk om het `decay_niveau:` hoger te zetten dan het `sustain_niveau:`:

    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

![ASR envelope](../images/tutorial/env-decay-level-2.png

## ADSR Enveloppen

Dus samengevat , hebben Sonic Pi’s ADSR enveloppen de volgende fasen:

attack - tijd vanaf 0 amplitude naar `attack_niveau`, decay - tijd om de amplitude van `attack_niveau` naar `decay_niveau` te brengen, sustain - tijd om de amplitude van `decay_niveau` naar `sustain_niveau` te brengen, release - tijd om de amplitude van `sustain_niveau` naar 0 te brengen

Het is belangrijk op te merken dat de duur van een geluid de som is van van de tijd van elk van deze fasen. Daarom zal het volgende geluid een duur van 0,5 + 1 + 2 + 0,5 = 4 hebben:

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

Nu gaan we hiermee spelen, door deze envelop aan jouw klanken toe te voegen…

# 3 - Samples

Een andere goede manier om je muziek op te bouwen is het gebruik van vooraf opgenomen geluiden. In de traditie van de hip-hop, noemen we deze vooraf opgenomen geluiden samples. Dus, als je met een microfoon buiten gaat en je neemt het geluid van de regen op, dat zachtjes tegen een zeil tikt, heb je een sample gemaakt.

Sonic Pi laat je allerlei prettige dingen doen door gebruik te maken van samples. En niet alleen omdat deze over de 90 samples aan boord heeft waar je mee aan de slag kan gaan, ook laat het je toe om jouw eigen samples te gebruiken en deze te manipuleren. We vertrekken…

# 3.1 - Samples Triggeren

Bliepjes spelen was slechts het begin. Vooraf opgenomen samples triggeren is ook echt fijn . Probeer het:

    sample :ambi_lunar_land

Sonic Pi bevat vele samples waarmee je aan de slag kunt gaan. Je kan ze gebruiken met het `play` commando, net zoals de bliepjes. Als je meerder samples en noten wil gebruiken kan je ze dus achter elkaar schrijven:

    play 36
    play 48
    sample :ambi_lunar_land
    sample :ambi_drone

Als je ze in tijd wil verspreiden, maak dan gebruik van het `sleep` commando:

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

Merk op hoe Sonic Pi niet zal wachten om een geluid te voltooien voordat het volgende geluid begint. De opdracht `sleep` beschrijft alleen de scheiding tussen het activeren van de geluiden. Hierdoor kan je makkelijk verschillende lagen van klanken creëren die een interessant effect kunnen hebben door overlapping. Verderop in deze handleiding zullen we een kijkje nemen om de duur van geluiden met enveloppen in te stellen.

## Samples Ontdekken

Er zijn twee manieren om samples in Sonic Pi te verkennen. Eerst, kunt u dit hulp-systeem gebruiken. Klik op Samples in het meest linkse verticale menu, kies uw categorie en vervolgens ziet u een lijst met beschikbare geluiden.

Alternatief kan je het auto-vervollediging systeem gebruiken. Typ enkel het begin van de groep waartoe de sample behoort zoals `sample :ambi_` en je zal een menu zien openklappen waarin de samples weergegeven worden die je kan selecteren. Probeer de volgende categorie-voorvoegsels:

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

Begin nu de samples in je composities te mixen!

# 3.2 - Sample Parameters: Amp en Pan

Zoals we met synths zagen, kunnen we gemakkelijk onze geluiden met parameters regelen. Samples steunen op precies hetzelfde parameter mechanisme. Laten we opnieuw onze vrienden `amp:` en `pan:` erbij halen.

## Samples amp-en

Je kan de amplitude van de samples met precies dezelfde aanpak instellen die je voor synthesizers gebruikt:

    sample :ambi_lunar_land, amp: 0.5

## Samples Pannen

We kunnen ook gebruik maken van de `pan:` parameter op samples. Bijvoorbeeld, hier zouden we de amen break met het linker oor en halverwege met het rechter oor horen:

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

Merk op dat 0.877 de helft van de lengte is, van de ‘: loop_amen’ sample in seconden uitgedrukt.

Hou er tenslotte ook rekening mee dat als je sommige synths van het commando `use_synth_defaults` voorziet (welke we later zullen bespreken), deze door `sample` zullen genegeerd worden.

# 3.3 - Samples Stretchen

Nu we met verschillende synths en samples muziek kunnen gaan spelen, is het tijd om te leren hoe je zowel de synths als de samples in kan stellen om de muziek nog meer uniek en interessant te maken. Ten eerste, laten we de mogelijkheid onderzoeken om te samples te stretchen of te krimpen.

## Sample Representatie

Samples zijn eigenlijk vooraf opgenomen geluiden die opgeslagen zijn als getallen die het verplaatsen van de conus van de luidspreker veroorzaken, om het geluid te kunnen representeren. De conus van de luidspreker kan zich naar voor en naar achter verplaatsen , en dus hoeven de nummers alleen maar weer te geven, hoe ver in en uit de kegel op elk moment in de tijd moet bewegen. Om een getrouwe afspiegeling van een opgenomen geluid te kunnen zijn moet de sample meestal vele duizenden nummers per seconde opslaan! Sonic Pi neemt deze lijst van nummers en voedt hen met de juiste snelheid, om de luidspreker van uw computer op de juiste manier in en uit te verplaatsen om het geluid te kunnen weergeven. Het is echter ook leuk om de snelheid waarmee de nummers worden gevoed aan de luidspreker te veranderen, om het geluid te veranderen .

## Koers wijzigen (rate)

Laten we even spelen met één van de ambient sounds: `:ambi_choir`. Om deze af te spelen op de standaard ingestelde koers, kan je een `rate:` optie aan `sample` doorgeven:

    sample :ambi_choir, rate: 1

Deze speelt de normale koers (1), nog niets bijzonders dus. We zijn echter vrij om dat cijfer te veranderen naar iets anders. Hoe zit het met ‘0.5’:

    sample :ambi_choir, rate: 0.5

Woah! Wat gebeurt hier? Nou, twee dingen. Ten eerste, de sample duurt twee keer zo lang in deze weergave, ten tweede is het geluid een octaaf lager. Laten we deze dingen meer in detail gaan bekijken.

## Laten we stretchen

Een sample die is leuk om te stretchen en te comprimeren is de Amen Break. Op normale koers, kunnen we het ons voorstellen deze in een drum ‘n’ bass track te gooien:

    sample :loop_amen

Door de koerssnelheid te veranderen kunnen we van genre schakelen. Probeer eens halve snelheid voor old school hiphop:

    sample :loop_amen, rate: 0.5

Als we het versnellen, komen we op het grondgebied van jungle:

    sample :loop_amen, rate: 1.5

En nog een laatste truc - laten we eens kijken wat er gebeurt als we gebruik maken van een negatieve koers:

    sample :loop_amen, rate: -1

Woah! Nu speelt het achteruit! Proberen nu met een heleboel verschillende samples aan verschillende koerssnelheden te spelen. Probeer zeer snelle rates. Probeer gek trage rates. Zie welke interessante geluiden je zo kan produceren.

## Een eenvoudige uitleg over de Sample Rate

Een handige manier van denken is om samples te zien als een veer. Afspeel snelheid is als het stretchen en indrukken van de veer. Als je de sample aan snelheid (rate) 2 afspeelt, ben je de veer aan het indrukken met de helft daarvan, heb je de veer in rust. Het neemt de sample dus de helft van de tijd om te spelen, aangezien deze nu korter is. Als je de sample aan half tempo speelt, stretch je de veer tot het dubbele van zijn lengte. De sample neemt daarom tweemaal zolang tijd om te spelen, aangezien deze nu langer is. Hoe meer u indrukt (hogere snelheid), hoe korter deze wordt, hoe meer je stretcht (lagere snelheid), hoe langer deze wordt.

Het comprimeren van een veer verhoogt de dichtheid (het aantal windingen per cm) - deze is vergelijkbaar met de sample die dan hoger gepitcht klinkt. De veer rekken neemt de dichtheid af en is dan vergelijkbaar met het geluid met een lagere toonhoogte.

## De wiskunde achter Sample Rate

(Deze sectie is bedoeld voor degenen die geïnteresseerd zijn in de details. Je kan deze gerust overslaan…)

Zoals we hierboven zagen, wordt een sample vertegenwoordigd door een grote lange lijst nummers, die de luidspreker vertelt waar deze zou moeten zijn doorheen een zekere tijd. We kunnen deze lijst van getallen gebruiken om bv. deze grafiek te tekenen:

Misschien hebt u al wel eens afbeeldingen gezien zoals deze. Het is een geluidsgolf van een sample.Het is gewoon een grafiek van getallen. Meestal zal een golfvorm 44100 punten per seconde bevatten over de gegevens (dit is te wijten aan de Nyquist-Shannon sample-theoriën). Dus, als de sample 2 seconden duurt, za de golfvorm vertegenwoordigd worden door 88200 nummers die we aan de luidspreker met een snelheid van 44100 punten per seconde zouden voeden. Natuurlijk, kunnen we deze aan dubbele snelheid voeden, dat zou dan 88200 punten per seconde zijn. Dit zou dus slechts 1 seconde in beslag nemen om af te spelen. We kunnen ook aan halve snelheid afspelen, dat zou 22050 punten per seconde zijn waarbij deze 4 seconden nodig heeft om af te spelen.

De duur van de sample wordt beïnvloed door de afspeelsnelheid (rate):

De afspeelsnelheid verdubbelen, halveert de afspeeltijd, Halvering van de afspeelsnelheid, verdubbelt de afspeeltijd, Een kwart van de afspeelsnelheid, verviervoudigt de speeltijd, 1/10 van de afspeelsnelheid, maakt het afspelen 10 keer langer.

Wij kunnen deze representeren met de formule:

    new_sample_duur = (1 / rate) * sample_duur

De afspeelsnelheid zal ook de toonhoogte van de sample wijzigen. De frequentie of toonhoogte van een golfvorm wordt bepaald door hoe snel deze op en neer beweegt. Onze hersenen vormen de snelle beweging van luidsprekers om tot hoge noten en de trage beweging tot lage noten. Daarom kan je soms zelfs zien hoe uit een grote bas luidspreker de super lage tonen worden gepompt, en in feite gaan deze veel trager dan een luidspreker die hoge noten reproduceert.

Als je een golfvorm neemt van een geluid en deze over de lengte samendruk,t zal deze per seconde vaker op en neer gaan. Dit zal het geluid hoger laten klinken.Het blijkt dat een verdubbeling van het aantal op en neer bewegingen (trillingen) de frequentie verdubbelt . Ook zal bij het afspelen van je sample aan dubbele rate, de frequentie verdubbelen die je hoort. Dus ook zal een halvering van de rate waarde, de frequentie halveren. Andere waarden zullen de frequenties dan naargelang beïnvloeden.

# 3.4 - Envelop op Samples

Het is ook mogelijk om de duur en amplitude te wijzigen van een samples met behulp van een ADSR-envelop. Nochtans, werkt dit enigszins anders dan de ADSR envelop voor synths. Sample enveloppen kunnen alleen de amplitude en de duur van een sample verminderen - en nooit om deze te verhogen. De sample wordt gestopt wanneer de sample is afgespeeld of de envelop heeft voltooid - welke van deze het eerst is. Dus, bij een erg lange release:`, het zal de sample niet verlengen.

## Amen Envelop

Laten we terugkeren naar onze trouwe vriend de Amen Break:

    sample :loop_amen

Zonder opties zullen we de volledige sample horen aan normale volle amplitude. Als we deze met behulp van het volume in willen mixen over een tijd van 1 seconde kunnen we de `attack:` parameter gebruiken:

    sample :loop_amen, attack: 1

Voor een kortere fade in, kies een kleinere waarde voor de attack:

    sample :loop_amen, attack: 0.3

## Auto Sustain

Waar de ADSR envelop zeker van gedrag verschilt met de standaard synth-envelop is in de sustain waarde. In de standaard synth envelop, is de sustain waarde, standaard op 0 ingesteld, tenzij u deze handmatig instelt. Met samples, is de sustain waarde, standaard een automagische waarde - namelijk de speelduur die de sample rest . Dit is de reden waarom we de totale sample horen als we geen waarden instellen. Als de attack, decay, sustain en release waarden allen 0 waren zouden we niks horen . Sonic Pi berekent dus hoe lang de sample is, trekt elke attack, decay en release tijden af en wordt het resultaat, de sustain tijd. Als de som van de attack, decay en release waarden meer dan de duur van de sample zijn, is de sustain gewoon ingesteld op 0.

## Fade Outs

Om deze te ontdekken, laten we dan onze Amen break in meer detail bekijken. Als wij Sonic Pi nu eens vragen hoe lang de sample is:

    print sample_duration :loop_amen

Het zal `1.753310657596372` uitprinten wat de de lengte is van de sample in seconden uitgedrukt. Laten we dit gewoon even afronden naar ‘1,75’ voor het gemak hier. Nu, als we de release naar ‘0,75’ instellen zal er iets verrassend gebeuren:

    sample :loop_amen, release: 0.75

Het zal de eerste seconde van de sample met volledige amplitude afspelen voordat deze dan uit-fade over een periode van 0.75 seconden. Dit is de auto sustain in actie. Standaard werkt de release altijd vanaf het einde van de sample. Als onze sample 10.75 seconden lang was, zou het de eerste 10 seconden spelen met volledige amplitude vooraleer deze met 0.75s uit te fade-en .

Dus onthoud: standaard geeft de release, aan het einde van de sample, een fade-out .

## Fade In en Uit

We kunnen `attack:` een `release:` samen met het gedrag van de auto sustain gebruiken om in de duurtijd van de sample in en uit te fade-en:

    sample :loop_amen, attack: 0.75, release: 0.75

Als de totale duurtijd van de sample 1.75s is en onze attack en release fase opgeteld 1.5 is, wordt de sustain fase automatisch op 0.25 ingesteld. Dit staat ons toe van makkelijk in en uit te fade-en.

## Expliciete sustain

We kunnen makkelijk naar ons normale synth ADSR gedrag terugkeren door de `sustain:` manueel naar een waarde te brengen zoals bv. 0:

    sample :loop_amen, sustain: 0, release: 0.75

Nu zal onze sample in totaal 0.75s spelen. Met de standaard waarden voor `attack:` en`decay:` van 0, springt de sample recht naar volle amplitude, zal 0s sustain-en maakt een neerwaardse release tot amplitude 0 over een periode van 0.75s.

## Percussieve cymbalen

We kunnen dit gedrag goed gebruiken om langer klinkende geluiden om te zetten naar korte, meer percussieve geluiden. We overwegen dit even met de sample `:drum_cymbal_open`:

    sample :drum_cymbal_open

Je hoort het cimbaal over een zekere periode uitzingen. We kunnen nu de envelop gebruiken om deze meer percussief te maken:

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

Je kan het slaan op de cymbaal, en het dempen ervan veranderen, door de sustain fase te vergroten:

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

Leef je uit door aan samples een envelop toe te voegen. Probeer ook de rate te veranderen voor echt interessante resultaten.

# 3.5 - gedeeltelijke Samples

Deze sectie zal onze verkenning afsluiten van Sonic Pi’s sample player. Laten we een snelle samenvatting maken. Tot nu toe hebben we gekeken hoe we samples kunnen triggeren:

    sample :loop_amen

Vervolgens hebben we gekeken hoe we de rate kunnen wijzigen naar bv. het afspelen op halve snelheid:

    sample :loop_amen, rate: 0.5

Verder hebben we gekeken hoe we deze sample konden in fade-en (we doen deze op halve snelheid):

    sample :loop_amen, rate: 0.5, attack: 1

We hebben ook gekeken hoe we de start van een sample meer percussief kunne maken door aan de `sustain:` een expliciete waarde te geven en aan zowel de attack als de release korte waarden te geven:

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

Zou het niet leuk zijn, als we deze niet altijd hoeven te laten starten vanaf het begin van de sample? Zou het niet leuk zijn, als we deze niet altijd hoeven te laten stoppen tot het einde van de sample?

## Startpunt kiezen

Het is mogelijk om een willekeurige startpunt in de sample te kiezen als een waarde tussen 0 en 1, waarbij 0 is het begin van de sample 1 is het einde en 0,5 is halverwege sample. Laten we proberen om alleen de laatste helft van de amen break te spelen:

    sample :loop_amen, start: 0.5

Of het laatste kwart van de sample:

    sample :loop_amen, start: 0.75

## Eindpunt kiezen

Ook is het mogelijk om een willekeurig eindpunt te bepalen in de sample met een waarde tussen 0 en 1. Laat ons de Amen Break halverwege doen stoppen:

    sample :loop_amen, finish: 0.5

## Specifieke begin- en eindpunten opgeven

Natuurlijk kunnen we deze alle twee gebruiken om elk willekeurig segment van het audiobestand af te laten spelen. Hoe zit dat met een heel kleine sectie ergens in het midden:

    sample :loop_amen, start: 0.4, finish: 0.6

Wat gebeurd er als we een startpunt achter het eind punt kiezen?

    sample :loop_amen, start: 0.6, finish: 0.4

Cool! Het speelt achterstevoren!

## Combineren met rate

We kunnen deze nieuwe mogelijkheid combineren om een willekeurige selectie in ons audiofragment met onze oude vriend `rate:`. We kunnen bijvoorbeeld een heel klein stukje in het midden van onze amen break sample traag laten afspelen:

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

## Combineren met de envelop

Tot slot kunnen we dit alles combineren met onze ADSR envelop om tot interessante resultaten te komen:

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

Experimenteer er nu maar even op los en maak leuke mash-ups van samples met deze toffe nieuwigheden…

# 3.6 - Externe Sample

Terwijl de ingebouwde samples je direct lanceren om mee aan de slag te laten gaan, wil je misschien experimenteren met ander vooraf opgenomen materiaal om jouw muziek mee te maken. Sonic Pi ondersteund dit ook. Vooraleerst, gaan we eerst even snel iets anders bespreken nl. de portabiliteit van jouw muziekstuk.

## Portabiliteit

Wanneer je je muziekstuk louter met de ingebouwde synth’s en samples componeert, is de code het enige wat je nodig hebt om een getrouwe weergave van jou muziek te horen. Fantastisch toch,als je hier even over nadenkt! Een simpel stukje tekst dat je rond kan e-mailen of in een Gist kan steken, vertegenwoordigd alles wat je nodig hebt om jouw klanken te laten horen. Dit maakt het echt makkelijk om te delen met jouw vrienden, daar zij alleen over jouw stukje code moeten beschikken.

Als je echter met je eigen voor-opgenomen samples begint te werken verlies je deze portabiliteit. Dit komt omdat je nu niet alleen de code nodig hebt, maar ook de samples om je muziek getrouw af te spelen. Dit beperkt de mogelijkheid voor anderen om met jouw werk te gaan experimenteren, te manipuleren of een mash up van te maken. Natuurlijk mag dit jou niet tegenhouden om je eigen samples te gaan gebruiken, gewoon om even bij stil te staan.

## Lokale Samples

Dus hoe speel je elke willekeurige WAV-, AIFF- of FLAC-bestand op uw computer? Het enige wat je hoeft te doen is het pad opgeven van het bestand naar `sample`:

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

Sonic Pi zal deze samples automatisch laden en afspelen. Je kan ook alle standaard parameters toewijzen aan deze doorgegeven `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 - Sample Packs

Opmerking dit gedeelte van de handleiding behandeld een meer geavanceerd thema, nl. over het werken met grote bestanden van eigen samples. Dit zal bijvoorbeeld het geval zijn als je sample packs kocht of hebt gedownload en deze in Sonic Pi wenst te gebruiken.

U mag dit gedeelte gerust overslaan wanneer je tevreden bent met de ingebouwde samples.

Wanneer je werkt met grote mappen van externe samples kan het erg onhandig zijn om telkens het hele pad te typen die jouw eigen samples triggeren.

Bijvoorbeeld, stel dat je de volgende map hebt op je computer:

    /path/to/my/samples/

Als we in die map kijken vinden we de volgende voorbeelden:

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

Om de piano sample te spelen gebruiken we dan normaal gezien het volledige pad:

    sample "/pad/naar/mijn/samples/120_Bb_piano1.wav"

Om vervolgens de gitaar sample te willen gebruiken we ook het volledige pad:

    sample "/pad/naar/mijn/samples/120_Bb_guit.wav"

Echter, om beide samples op te roepen zijn we genoodzaakt te weten welke de naam is van deze samples in onze map. Wat als we snel door onze samples willen gaan om deze even te beluisteren?

## Sample Packs Indexeren

Als we de eerste sample binnen een map willen spelen moeten we alleen de naam van de map doorgeven aan `sample` en de index `0` als volgt:

    sample "/pad/naar/mijn/samples/", 0

We kunnen zelfs een binnenweg maken naar ons pad van de map met behulp van een variabele:

    samps = "/pad/naar/mijn/samples/"
    sample samps, 0

Als we dan de tweede sample in onze folder willen afspelen, moeten we gewoon 1 aan onze index toevoegen:

    samps = "/pad/naar/mijn/samples/"
    sample samps, 1

Merk op dat we hierbij niet meer de naam van de sample in de map hoeven op te geven, alleen de map zelf (of de snelkoppeling). Als we nu een indexnummer zouden gebruiken dat hoger is dan het aantal samples, gaan de eerste samples in de map terug aan de beurt komen, als in een kring werpt deze er zich rond. Welk nummer we ook gaan gebruiken, we komen gegarandeerd één van onze samples tegen in deze map.

## Sample Packs Filteren

Meestal is indexeren genoeg, maar soms moeten we wat meer “power” hebben om onze samples te sorteren en te organiseren. Gelukkig voegen veel sample packs nuttige informatie in de bestandsnamen toe. Laten we nog eens kijken naar de sample-bestandsnamen in onze folder:

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

Merk op dat we in deze bestandsnamen vrij veel informatie hebben. Ten eerste hebben we de BPM van de sample (beats per minute) aan het begin. Dus, de piano sample bedraagt 120 BPM en onze eerste drie melodieën hebben 100 BPM. Ook bevatten onze samples,de toonhoogte (key). Dus de sample van de gitaar is in Bb en de melodieën zijn in A #. Deze informatie is zeer nuttig bij het mengen van deze samples, samen met onze andere code. Bijvoorbeeld, nu weten we dat de piano sample enkel in een code past die 120 BPM heeft met toonhoogte van Bb.

Het komt wel goed uit dat we deze bijzondere naamgeving van onze sample sets ook in de code kunnen gebruiken om onze samples uit te filteren naar degene die we willen. Bijvoorbeeld, als we op 120 BPM werken, kunnen we als volgt, alle samples uitfilteren die de tekenreeks `"120"` bevatten:

    samps = "/pad/naar/mijn/samples/"
    sample samps, "120"

Deze zal ons een eerste filtering opleveren. Als we verder willen gaan zoeken naar een sample die goed past, kunnen we de index gebruiken:

    samps = “/pad/naar/mijn/samples/"
    sample samps, "120", 1

We kunnen zelfs meerdere filters tegelijk gebruiken. Bijvoorbeeld, als we willen dat een sample waarvan de bestandsnaam zowel de subtekenreeksen “120” en “A#” bevat, kunnen we die met de volgende code gemakkelijk terugvinden:

    samps = "/pad/naar/mijn/samples/"
    sample samps, "120", "A#"

Voorts zijn we nog altijd vrij om onze gebruikelijke opties voor de weergave van onze `sample` toe te voegen:

    samps = "/pad/naar/mijn/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2

## Bronnen

Het prearg(-umenten) van het sample filtersysteem herkent twee informatie types: bronnen en filters. Bronnen worden gebruikt om een lijst van potentiële te maken. Een bron kan twee vormen aannemen: Een bron kan twee vormen aannemen:

“/pad/naar/samples” - een tekenreeks dat een geldig pad naar een map weergeeft “/pad/naar/samples/blabla.wav” - en tekenreeks die een geldig pad naar een sample weergeeft

De `sample` functie zal eerst alle bronnen verzamelen en deze gebruiken om een lange lijst van kandidaten te maken.Deze lijst wordt gevormd door eerst alle geldige paden toe te voegen en daarna alle geldige `.flac`, `.aif`, `.aiff`, `.wav`, `.wave` bestanden die deze mappen bevatten.

Kijk bijvoorbeeld even naar deze code:

    samps = "/pad/naar/mijn/samples/"
    samps2 = "/pad/naar/mijn/samples2/"
    path = "/pad/naar/mijn/samples3/foo.wav"
    sample samps, samps2, path, 0

Hier combineren we de inhoud van de samples binnen twee mappen en het toevoegen van een specifieke sample. Als `"/pad/naar/mijn/samples/"` 3 samples bevat en `"/pad/naar/mijn/samples/"` bevat er 12, zouden we 16 potentiële samples om te indexeren en te filteren hebben (3 + 12 + 1).

Standaard worden alleen de voorbeeldbestanden binnen een map in de lijst met kandidaten verzameld. Soms heb je misschien een aantal geneste mappen van samples die je lokaal wil gaan zoeken en filteren. Je kan daarom een recursieve zoekopdracht voor alle samples in alle sub-mappen van een bepaalde map doen door toevoeging van `**` aan het einde van het pad:

    samps = "/pad/naar/geneste/samples/**"
    sample samps, 0

Hou er wel rekening mee dat als je door een groot aantal folders gaat zoeken,dit veel tijd in beslag kan nemen. Maar de inhoud van alle folderbronnen worden ge-cached, dus de vertraging zal maar één keer optreden.

Ten slotte, merk op dat de bronnen eerst moeten gaan. Als er geen bron is opgegeven, zal de set van ingebouwde samples geselecteerd worden als de standaardlijst van kandidaten om mee te werken.

## Filters

Als u eenmaal een lijst van kandidaten hebt mag u het volgende filter typen om de selectie verder te reduceren:

`"foo"` Tekenreeksen zullen filteren op sub-tekenreeksen gebeurtenissen binnen de bestandsnaam (min het pad van de map en de extensie). `/fo[oO]/` Reguliere expressies zullen filteren op patroonherkenning van bestandsnamen (min het pad van de map en de extensie). `:foo` -trefwoorden zullen naar kandidaten filteren op basis van hun gelijkenis met de bestandsnaam (min het pad van de map en extentie). `lambda{|a| ... }` - Procedures met één argument zullen als een kandidaat-filter gezien worden of als een genereer-functie. Het zal worden doorgegeven aan de lijst van de huidige kandidaten en moet een nieuwe lijst van kandidaten oproepen ( een lijst met geldige paden naar sample bestanden). `1` - Nummers zullen de kandidaat met dit index selecteren (en als een kring rond gaan als dit nodig is).

We kunnen bijvoorbeeld alle samples filteren in een map die bevat de tekenreeks `"foo"` bevat en de eerste overeenkomende sample spelen op halve snelheid:

    sample "/pad/naar/samples", "foo", rate: 0.5

Zie hulp voor `sample` voor vele gedetailleerde gebruiksvoorbeelden. Merk op dat de volgorde van de filters geëerd wordt.

## Mengsels

En tot slot, je mag lijsten gebruiken waar ook je een bron of filter kan plaatsen. De lijst zal automatisch afgevlakt worden en hun inhoud zal als reguliere bronnen en filters behandeld worden. Daarom zijn de volgende aanroepen naar `sample`, semantisch equivalent:

    sample "/pad/naar/map", "100", "C#"
    sample ["/pad/naar/map", "100", "C#"]
    sample "/pad/naar/map", ["100", "C#"]
    sample ["/pad/naar/map", ["100", ["C#"]]]

## Rond Wikkelen

Dit was een geavanceerd gedeelte voor mensen die veel kracht om sample packs te manipuleren en gebruiken nodig hebben. Moest het meeste van dit deel vraagtekens oproepen, geen nood. Waarschijnlijk hebt u dan deze functionaliteit nu nog niet echt nodig. Je zal wel merken wanneer je er aan toe bent om dan terug te keren naar dit gedeelte om met grote sample bestanden te gaan werken.

# 4 - Randomiseren

Een geweldige manier om jouw muziek interessant te maken is het gebruik van willekeurige getallen. Sonic Pi heeft een goede functionaliteit om willekeurigheid in jouw muziek toe te voegen, maar eerst moeten we naakte waarheid onder ogen zien: in Sonic Pi is random geen echte random. Wat heeft dit nu weer te betekenen? Laat ons eens kijken.

## Herhaalbaarheid

Een heel nuttige willekeurige functie is ‘rrand’, welke je een willekeurige waarde tussen twee nummers geeft - een min en max. (‘rrand’ is kort voor ranged random (willekeurigen binnen een bepaald bereik)). Laten we proberen een willekeurige opmerking te spelen:

    play rrand(50, 95)

Ooh het speelt een willekeurige noot. Het speelde de noot `83.7527`. Een mooie willekeurige noot tussen 50 en 95. Hu, heb ik nu net de willekeurige noot die jij ook had exact voorspeld? Hier is iets verdacht gaande. Probeer de code nu nog eens opnieuw uit te voeren. Wat?? Het koos `83.7527` opnieuw? Niet echt random dus!

Het antwoord is, dat deze niet echt random is, maar pseudo-random. Sonic Pi zal jou random-achtige cijfers geven op een repetitieve manier. Dit is heel nuttig om ervoor te zorgen dat jouw muziek,gemaakt op jou toestel, hetzelfde klinkt op iemand anders toestel, ook al heb je de functie van randomiseren gebruikt in je compositie.

Natuurlijk, bij een zeker stukje muziek, moest het elke keer ‘random’ `83.7527` kiezen, dan zou het niet interessant meer zijn. Maar dat doet het niet. Probeer het volgende:

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

Ja, Eindelijk klinkt het random. Binnen een gegeven doorloop gaan de volgende opvragingen naar random functies randum waarden weergeven. Bij de daar opvolgende doorloop gaan zij echter exact dezelfde sequentie van deze random waarden spelen en dus net hetzelfde klinken. Alsof Sonic Pi terug in de tijd ging naar exact hetselfde punt elke keer de afspeelknop werd ingedrukt. De “Groundhog Day” in de wereld van muziek synthese!

## “Haunted Bells”

Een mooie illustratie van randomiseren in actie is het voorbeeld “haunted bell’s” die de `:perc_bell`’ sample laat “loop-en” met een willekeurige rate en sleep tijd tussen de klokkengeluiden:

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

## Random cutoff

Een ander leuk voorbeeld van randomiseren is het willekeurig wijzigen van de cutoff van een synth. Een geweldige synth om dit op uit te proberen is de ‘: tb303’ emulator:

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

## Random “seeds”

Dus, wat als deze bijzondere reeks willekeurige getallen die Sonic Pi biedt je niet bevalt ? Nou is het volledig mogelijk om een ander uitgangspunt te kiezen via ‘use_random_seed’. De standaard seed instelling is 0, kies dus een andere seed voor een andere ervaring in randomisering!

Houd rekening met het volgende:

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

Telkens wanneer u deze code uitvoert, zult u dezelfde sequentie van 5 noten horen. Voor een andere volgorde verander gewoon de seed:

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

Dit zal een andere sequentie van 5 noten produceren. Door het veranderen van de seed en door het beluisteren van de resultaten vindt u wel iets dat u goed vind - en wanneer u deze met anderen deelt, horen zij precies wat u ook hebt gehoord.

Laten we eens kijken naar enkele andere nuttige randomisering functies.

## choose

Een zeer gebruikelijk actie zou zijn, random te kiezen uit een lijst van gekende items. Bijvoorbeeld, ik zou één van de volgende noten willen spelen: 60, 65 of 72. Ik kan dit bewerkstelligen met `choose` die mij een item uit een lijst laat kiezen. Eerst moet ik mijn getallen in een lijst zetten, hetgeen ik kan doen door deze in rechthoekige haakjes te plaatsen en door middel van komma’s te scheiden: : `[60, 65, 72]. Vervolgens moet ik deze doorgeven aan` choose`:

    choose([60, 65, 72])

Laten we eens horen hoe dat klinkt:

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

## rrand

We hebben `rrand` al gezien, maar laat ons deze nog even overlopen. Deze reproduceert een willekeurig getal tussen twee getallen die hierbij exclusief zijn. Dit wil zeggen dat deze getallen,noch het onderste, noch het bovenrste zal weergeven worden, maar altijd een getal tussen die twee. Het getal zal altijd een niet-geheel getal zijn- wat betekend dat dit nooit een geheel getal zal zijn, maar een breuk van een getal. Voorbeelden van niet-gehele getallen die worden gereproduceerd door `rrand(20, 110)`:

87.5054931640625 86.05255126953125 61.77825927734375

## rrand_i

Soms zal je een geheel getal, willen doen uitkomen in plaats van een niet-geheel getal in de ranomisering. Hier komt `rrand_i` redding brengen. Dit werk het zelfde als `rrand` behalve dat deze hier de min en max waarden als potentiële random waarden laat uitkomen (inclusief ipv. exclusief bereik). Voorbeelden van getallen die gereproduceerd kunnen worden door `rrand` zijn:

88 86 62

## rand

Dit geeft een willekeurig niet-geheel getal tussen 0 (inbegrepen) en de max waarde die u opgeeft (exclusieve). Standaard wordt een waarde tussen 0 en 1 geretourneerd. Daarom is deze nuttig voor het kiezen van willekeurige ‘ amp:’ waarden:

    loop do
      play 60, amp: rand
      sleep 0.25
    end

## rand_i

Vergelijkbaar met de relatie tussen ‘rrand_i’ en ‘rrand’, ‘rand_i’ geeft een willekeurig geheel getal tussen 0 en de max waarde die u opgeeft.

## dice (teerling)

Soms wil je een gooi van een dobbelstenen nabootsen - dit is een speciaal geval van ‘rrand_i’ waar de laagste waarde altijd 1 is . Een oproep naar de ‘dobbelstenen’ moet je het aantal zijden op de dobbelsteen opgeven. Een standaard dobbelsteen heeft 6 zijden, en zal ‘dice(6)’ zich ook zo gaan gedragen - en waarden van ofwel 1, 2, 3, 4, 5 of 6 reproduceren.Maar misschien wil je wel, net zoals in een fantasy rollenspel , een 4-zijdige dobbelstenen, of een 12 zijdige dobbelstenen, of een 20 zijdige dobbelsteen - misschien zelfs een 120 zijdige dobbelsteen!

## one_in

Tot slot wil je ook de gooi naar het hoogste getal nabootsen, zoals onze 6 op een normale dobbelsteen. `one_in` zal daarom de waarde true met een kans van één op het aantal zijden op de dobbelsteen reproduceren. Daarom geeft `one_in(6)` true met een waarschijnlijkheid van 1 in 6 terug, en anders false . True en False waarden zijn zeer nuttig voor `if` verklaringen die wij in een latere sectie van dit leerprogramma zullen behandelen.

Maak maar even een wirwar aan Random-heid!

# 5 - Programmeerstructuren

Nu dat je de basis hebt geleerd om geluiden met ‘play’ en ‘sample’ te creëren , en eenvoudige melodieën en ritmes, door tussen de klanken `sleep` te gebruiken, kan je je nu gaan afvragen wat de wereld van code je nog heeft te bieden…

Nou, sta je voor een spannende traktatie! Het blijkt dat fundamentele programmeerstructuren zoals loops, conditionals, functies en threads jou ongelooflijk krachtige tools geven om jou muzikale ideeën uit te drukken.

We bijten ons vast in de basisbeginselen hiervan…

# 5.1 - Blocks

Een structuur die je vaak zal terugvinden in Sonic Pi is de blok-structuur. Deze “Blocks” kunnen ervoor zorgen dat we heel handig met grote happen code gaan kunnen omspringen. Met de Synth en sample parameters konden we deze al op een enkele lijn gaan veranderen. Soms willen we echter op een slimme manier verschillende lijnen kunnen aanspreken om hun parameters te gaan veranderen. Bijvoorbeeld, als we die willen loop-en, een reverb toe willen voegen, deze 1 van de vijf keer willen laten afspelen etc… Kijk dan even naar deze code:

    play 50
    sleep 0.5
    sample :elec_plip
    sleep 0.5
    play 62

Om iets met een stuk code-reeksen te laten gebeuren, moeten we Sonic Pi vertellen waar die blok van code moet starten en waar deze eindigt. Hiervoor gebruiken we `do` om te starten en `end` om te eindigen. Bijvoorbeeld:

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

Maar… we zijn er nog niet helemaal (als je dit zou uitproberen krijg je een foutmelding) want we hebben Sonic Pi nog niet verteld wat we willen doen met deze do/end block. Door een speciale code vóór de `do` te zetten kunnen we dit duidelijk maken aan Sonic Pi. We zullen deze speciale stukjes code later in deze handleiding bekijken. Het belangrijkste om weten nu, is dat als je je code inpakt met deze `do` en `end` je hiermee iets speciaal kan aanvangen.

# 5.2 - Herhaling en Loops

Tot nu toe hebben we al een heleboel tijd besteed aan de verschillende klanken die we kunnen maken met de `play` en `sample` lijnen. We hebben ook geleerd deze met een zekere regelmaat te triggeren met behulp van `sleep`.

Zoals je waarschijnlijk hebt ontdekt, je kan veel plezier beleven met deze basis bouwstenen. Er zal echter een nieuwe wereld voor je opengaan wanneer je de kracht van code gaat gebruiken om structuur te geven aan jouw muziek en composities. In de volgende secties gaan we enkele van deze krachtige hulpmiddelen verkennen. Vooraleerst zijn herhaling en loop aan de beurt.

## Repetitieve herhaling

Heb je wat code geschreven dat je graag een paar keer wil herhalen? Bijvoorbeeld, zoiets als deze::

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

Wat als wij deze 3 keer willen herhalen? Nou simpel, we kunnen deze drie keer kopiëren en plakken:

    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

Dat is wel een heleboel code! Wat als je nu de sample `:elec_plip` wil veranderen? Dan moet je de code helemaal afgaan en overal waar deze voorkomt vervangen door de nieuwe sample. En, nog belangrijker, wat als ik de code 50 of 1000 keer wil herhalen? Dat zou een heleboel code zijn, en heel wat regels wijzigen om een verandering te maken.

## Iteratie

In feite zou het herhalen van code zo eenvoudig moeten zijn als zeggen doe dit drie keer. Zo is het ook wel een beetje. Herinner je je onze oude vriend de code block nog? We kunnen hem gebruiken om het start- en eindpunt, van de code die we willen herhalen, aan te duiden. We gebruiken dan onze speciale code `3.times`. In plaats van doe dit drie keer, schrijven we `3.times do`, eenvoudig niet? Vergeet ook niet `end`op het einde van het te herhalen block te schrijven:

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

Nu is dat niet veel netter dan knippen en plakken! We kunnen dit gebruiken om allerlei leuke herhalende structuren te maken:

    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

## Geneste Iteraties

We kunnen iteraties binnen andere iteraties plaatsen om interessante patronen te creëren. Bijvoorbeeld:

    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

## Loop-en

Als je iets lang wil laten herhalen, ga je je misschien op betrappen van grote getallen te gebruiken zoals bv. `1000.times do`. In dat geval kan je Sonic Pi misschien beter opdragen van deze oneindig veel keer te herhalen ( als je tenminste niet op de stop-knop drukt,natuurlijk!) Laat ons de Amen Break eindeloos herhalen:

    loop do
      sample :loop_amen
      sleep sample_duration :loop_amen
    end

Belangrijk om weten is dat loops zich kunnen gedragen als zwarte gaten in je code. Eens de code in loop gaat, geraakt hij er niet meer uit tenzij je op stop drukt - de code blijft in deze loop doordraaien. Dit betekent dan, als je code hebt geschreven na de loop, je deze code nooit zal horen. In dit voorbeeld, zal de cymbaal na de loop nooit spelen:

    loop do
      play 50
      sleep 1
    end
    sample :drum_cymbal_open

Nu gaan we de code structureren met iteratie en loops!

# 5.3 - Conditionelen

Eén van de dingen die je op een zeker moment zeker wil gaan doen is,dat je niet alleen willekeurige noten wil spelen (zie de voorgaande sectie hierover) maar ook een willekeurige (random) beslissing kunnen maken en gebaseerd op de uitkomst van andere uitgevoerde code of andere code. Zo wil je bijvoorbeeld een drum of cimbaal willekeurig bespelen. Dit kunnen we bereiken met de instructie ‘als’.

## Een muntje opgooien

Laten we een muntje opgooien: Als het kop is, speel je een trommel, als het munt is, speel je een cimbaal. Makkelijk. We kunnen kop of munt nabootsen met onze `one_in` functie (voorgesteld in onze sectie over willekeurigheid) door een waarschijnlijkheid in te bouwen van 1 op 2: ‘one_in(2)’. We kunnen het resultaat,vervolgens gebruiken om te kunnen kiezen tussen twee stukken van de code, de code om de trommel te spelen en de code om de cimbaal te spelen :

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

      sleep 0.5

    end

Merk op dat ‘if’ verklaringen drie delen hebben:

De vraagstelling De eerste keuze van de uit te voeren code (als het antwoord op de vraag ja is) De tweede keuze van de uit te voeren code (als het antwoord op de vraag neen is)

Typisch in programmeertalen, wordt ja aangeduid door de term ‘true’ en neen door de term ‘false’. Dus moeten we een vraag vinden die ons een `true` of `false` antwoord geeft, dat is precies wat `one_in´ doet.

Merk op hoe de eerste keuze verpakt is tussen `if` en `else` en de tweede keus verpakt tussen `else` en `end`. Net zoals bij een do/end blok kun je meerdere coderegels in beide plaatsen zetten. Bijvoorbeeld:

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

    end

Dit keer hebben we verschillende rustijden afhankelijk van de keuze die wordt gemaakt.

## Gewoon if

Soms wilt je optioneel slechts één regel code uitvoeren. Dit is mogelijk door het plaatsen van `if` en vervolgens de vraag aan het einde. Bijvoorbeeld:

    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

Dit zal akoorden met andere getallen, bij iedere gespeelde noot, de kans op een verschillende mogelijkheid spelen.

# 5.4 - Threads

Dus je hebt je fatale baslijn en een vette beat. Hoe speel je ze op hetzelfde moment? Een oplossing is deze handmatig verweven- een beetje bas , dan wat drums, wat meer bas… Lang gaat het niet duren eer je je de timing moeilijk kan voorstellen, zeker als je nog meer elementen hierin wil verweven.

Wat als Sonic Pi deze automatisch kan verweven voor jou? Nou, het kan, en je het doet dat met wat heet een thread.

## Oneindige Loops

Om het voorbeeld eenvoudig te houden, moet je je voorstellen dat dit een waanzinnige baslijn is en een vette beat:

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

Zoals we reeds eerder bespraken, zijn loops zoals zwarte gaten voor het programma. Zodra je in loop bent geraakt, kan je deze niet verlaten totdat u op stop hebt gedrukt. Hoe spelen we dan deze beide loops op hetzelfde moment? We moeten Sonic Pi vertellen dat we iets op hetzelfde moment als de rest van de code willen beginnen. Dit is waar de threads ons redding brengen.

## Threads bieden redding

    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

Door de eerste loop in een `in_thread` do/end block te plaatsen, vertellen we Sonic Pi de inhoud van de do/end block uit te voeren op exact hetzelfde moment als de volgende instructie na de do/end block (toevallig ook onze tweede lus). Probeer het en je zal de baslijn en de drums samen horen spelen!

Wat als we hieraan nog een synth willen toevoegen? Zoiets als:

    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

Nu hebben we hetzelfde probleem als hiervoor. De eerste loop wordt gespeeld op hetzelfde moment als de tweede loop, door onze ‘in_thread’. De derde loop wordt weer nooit bereikt. Daarom hebben we een andere thread nodig:

    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

## Voert uit als threads

Wat je mischien zal verbazen is dat iedere keer je op de afspeel-knop drukt je eigenlijk een nieuwe thread aanmaakt voor de uitvoerende code. Vandaar dat, wanneer je meerdere keren op afspelen drukt, de klanken op elkaar hoort opstapelen. Vermits deze een thread op zich is, verweeft hij deze code voor jou automatisch.

## Toepassingsgebied

Als je Sonic Pi leert beheersen, ga je zien dat threads de belangrijkste bouwstenen voor jouw muziek zullen zijn. Eén van de belangrijkste taak die zij hebben is het isoleren van de huidige staat van andere threads. Wat betekend dit? Wel, wanneer je van synth overschakeld door het gebruik van `use_synth` schakel je van synth in de huidige thread - geen enkele andere thread zal van synth veranderen. Laten we dit in actie zien:

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

Merk je op dat de middelste klank anders is dan de andere? De `use_synth` declaratie zal enkel invloed hebben op de thread waarin deze zich bevind en niet op de threads daarbuiten.

## Erfenis

Wanneer je een nieuwe thread met `in_thread` creëert, zal de nieuwe thread de instellingen van de huidige thread overnemen. Laten we dit even bekijken :

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

Merk je op hoe de tweede noot met de ‘: tb303’ synth wordt gespeeld, hoewel het door een aparte thread werd aangestuurd? Elk van de met verschillende `use_*` functies gewijzigde instellingen, zullen zich op dezelfde manier gaan gedragen.

Wannneer threads worden gecreëerd, erven zij alle instellingen over van bovenliggende (parent) maar zij delen geen veranderingen aan hen terug.

## Naamgeving aan Threads

Ook nog kunnen wij namen geven aan 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

Kijk naar het log venster wanneer u deze code uitvoert. Zie je hoe het logboek de naam rapporteert van de thread met een bericht?

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

## Slechts één thread per naam toegestaan

Wat je nog moet weten over benoemde threads is dat slechts één thread met een bepaalde naam tegelijkertijd kan worden uitgevoerd. Laten we dit onderzoeken met de volgende code:

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

Ga je gang en plak deze in een buffer en druk op de knop afspelen. Druk er opnieuw een paar keer. Luister naar de kakofonie van meerdere amen breaks in loop, uit de maat afspelen . OK, je mag nu op Stop drukken.

Dit soort gedrag hebben we al keer op keer gezien - dat als je de afspeelknop aanklikt, geluidslagen op bestaande klanken gaan stapelen. Dus als je een loop hebt en je klikt drie keer op afspelen zal je drie lagen loops tegelijkertijd horen afspelen.

Met benoemde threads is dat echter anders:

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

Probeer de afspeel-knop meerdere malen met deze code. Je zal nu één enkele amen break loop horen. Ook zie je dit in het logboek:

    ==> Skipping thread creation: thread with name :amen already exists.

Sonic Pi vertelt je hier dat een thread met de naam `:amen` al aan het spelen is , en gaat geen andere creëren.

Dit gedrag lijkt misschien niet onmiddellijk bruikbaar voor je nu - maar het zal erg handig worden wanneer we beginnen met het spelen van code live…

# 5.5 - Functies

Zodra u veel code begint te schrijven, kan je als je wil, een manier vinden om dingen te gaan organiseren en structureren, om deze netter te maken en gemakkelijker te begrijpen. Functies zijn een zeer krachtige manier om dit te doen. Ze brengen ons de mogelijkheid om een naam te geven aan een bundel code. Laten we een kijkje nemen.

## Functies definiëren

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

Hier hebben we een nieuwe functie genaamd `foo` gedefinieerd. We doen dit met onze oude vriend het do/end blok en het magische woord `define` gevolgd door de naam die wij willen geven aan onze functie. We hoefde deze niet `foo` te noemen, we konden deze om het even wat noemen zoals `fiets`, `bal` of een ideale beschrijving zoals `refrein_stuk` of `lead_riff`.

Vergeet niet van een dubbele punt `:` bij de naam van je functie te voegen wanneer je deze definieert.

## Functies aanroepen

Eens we een functie hebben gedefinieerd kunnen we deze oproepen door gewoon zijn naam te schrijven:

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

We kunnen zelfs gebruik maken van ‘foo’ binnen iteratie blokken of overal waar we `spelen` of `samplen` hebben geschreven. Dit schenkt ons een geweldige manier om onszelf te uiten en nieuwe zinvolle woorden te gebruiken in onze composities.

## Functies worden onthouden langsheen het uitvoer commando

Tot nu toe was het zo, dat telkens als u de Afspeel-knop ingedrukte, Sonic Pi met een schone lei startte. Het weet weet van niets tenzij van wat er in de buffer zit. Je kan niet verwijzen naar code die in een andere buffer of een andere thread zit. Met functies veranderd dat. Wanneer je een functie definieert zal Sonic Pi zich deze herinneren. Laten we dit eens proberen. Verwijder alle code uit uw buffer en vervang het met:

    foo

Druk op de Afspeel-knop - en hoor je functie nu spelen. Zo zonder code? Hoe wist Sonic Pi wat het moest spelen? Sonic Pi herinnerde zich jouw functie - dus zelfs nadat je deze hebt gewist uit de buffer, het herinnerde zich wat jij had getypt. Dit gedrag werkt alleen met functies die zijn gemaakt met `define` (en `defonce`).

## geparametreerde functies

Interessant om weten ook is dat je net zoals je min als max waarden kan geven aan `rrand`, kan je ook jouw functies argumenten laten accepteren. Laat ons dat even bekijken:

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

Dit is niet erg spannend, maar het illustreert wel de zaak. We hebben onze eigen versie van `play` genaamd ‘my_player’ die is geparametriseerd.

De parameters moeten na de `do` van het `define` do/end blok komen te staan, omringd door een sluisteken `|`en gescheiden door komma’s `,`. Om deze parameters te benoemen mag je elk woord gebruiken dat je maar wil.

Het zit ‘h allemaal in de `define` do/end blok. Je kan de parameternamen gebruiken zoals echte waarden. In dit voorbeeld speel ik de noot `n. Je kan deze beschouwen als een soort toezegging, dat wanneer de code loopt, deze door de werkelijke waarden vervangen wordt wanneer je deze benoemd. Ik doe dit met` my_player 80`. om noot 80 te spelen. Binnen de definitie van deze functie, is` n`nu vervangen door 80, dus` play n`verandert in` play 80`. Wanneer ik deze vernoem met` my_player 90´, is `n` nu vervangen met 90, play `n`is veranderd in play `90`.

Laten we eens kijken naar een interessanter voorbeeld:

    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

Hier gebruikte ik `repeats` als een cijfer in de regel `repeats.times do`.Ik gebruikte `root` ook als naam van een noot in mijn `play` oproep.

Hierbij zien we dat we in staat zijn om iets zeer expressief, maar makkelijk leesbaar te schrijven door onze logica in een functie te steken!

# 5.6 - Variabelen

Het is handig om in jouw code is namen voor dingen te creëren. Sonic Pi maakt jou dit zeer eenvoudig, je schrijft de naam die je wenst te gebruiken, een gelijkteken (‘=’), en dan wat je wilt onthouden:

    sample_name = :loop_amen

Hier, we hebben het symbool `:loop_amen` ‘onthouden’ in de variabele `sample_name` . Nu kunnen we `sample_name` gebruiken, overal waar we `:loop_amen` hebben gebruikt. Bijvoorbeeld:

    sample_name = :loop_amen
    sample sample_name

Er zijn drie belangrijke redenen voor het gebruik van variabelen in Sonic Pi: in het communiceren, het beheer van herhaling en het vastleggen van de resultaten van zaken.

## In de zin van Communicatie

Als je code schrijft, denk ,je snel dat je je computer verteld wat hij moet doen, en zolang de computer deze kan verstaan, alles OK is. Maar het is ook belangrijk om er op te letten dat niet alleen de computer jouw code leest. Andere mensen kunnen deze ook lezen en proberen te begrijpen wat er gaande is. Ook, wil je waarschijnlijk jouw eigen code in de toekomst lezen en proberen te begrijpen hoe die werkt. Hoewel deze code voor jou nu vanzelfsprekend lijkt - is het misschien niet zo duidelijk voor anderen of zelfs je toekomstige zelf!

Een manier om andere jouw code te laten begrijpen is deze van een commentaar-lijn voorzien (zoals we in een voorgaande sectie hebben gezien). Een ander is zinvolle variabele namen gebruiken. Kijk naar deze code:

    sleep 1.7533

Waarom maakt men hier gebruik van het cijfer `1.7533`? Waar komt dit getal vandaan? Wat betekent het? En kijk nu eens naar deze code:

    loop_amen_duration = 1.7533
    sleep loop_amen_duration

Het is nu veel duidelijker wat ‘1.7533’ betekent: het is de duur van de sample `:loop_amen`! Natuurlijk, zou je kunnen zeggen, waarom schrijf je gewoon niet:

    sleep sample_duration(:loop_amen)

Wat natuurlijk een zeer mooie manier is om de intentie van de code te communiceren .

## Herhaling Beheren

Vaak zie je een heleboel herhaling in je code en als je dingen wil veranderen, moet je deze op een heleboel plaatsen veranderen. Kijk even naar deze 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)

We doen hier heel wat met ‘: loop_amen’! Maar als we nu willen horen hoe dit klinkt met een andere sample loop, zoals `:loop_garzul`? Dan zouden we deze moeten gaan zoeken en alle `:loop_amen`s met `:loop_garzul` vervangen’. Dat zou fijn zijn als je veel tijd hebt- maar wat als je dit uitvoert op het podium? Soms heb je de luxe van de tijd niet - vooral niet als je de mensen aan het dansen wil houden.

Wat als je je code als het volgt zou schrijven:

    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)

Nu dat doet net het zelfde als deze hierboven (probeer maar). Het geeft ons ook de mogelijkheid om één enkele lijn te moeten gaan veranderen: `sample_naam = :loop_amen` naar `sample_naam = :loop_garzul, en we veranderen deze op vele plaatsen binnen onze code door de magie van variabelen.

## Vastleggen van de resultaten

Tot slot, een goede motivatie om variabelen te gaan gebruiken is om resultaten van zaken vast te leggen. Misschien wilt u bijvoorbeeld iets doen met de duur van een sample:

    sd = sample_duration(:loop_amen)

We kunnen nu ‘sd’ overal gebruiken waar we de duur van de sample `:loop_amen` nodig hebben.

Wat misschien nog belangrijker is, een variabele stelt ons in staat het resultaat te capteren van een oproep naar `play` of `sample`:

    s = play 50, release: 8

Nu hebben we `s` gevangen en onthouden als een variabele, hetgeen ons toelaat de synth te controleren wanneer deze speelt:

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

We zullen het manipuleren van synth’s in een later sectie meer in detail bekijken.

## Waarschuwing: Variabelen en threads

Alhoewel variabelen goed zijn voor het geven van namen aan dingen en het opslaan van de resultaten van dingen, is het belangrijk om te weten dat ze typisch alleen lokaal gebruikt dienen te worden binnen een thread. Bijvoorbeeld, doe dit niet:

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

In het bovenstaande voorbeeld kenden we een ring van getallen toe aan variabele `a` en werd deze gebruikt in twee `live_loop`’s. In de eerste lus sorteren we de ring elke 0,5s (naar `(ring 1, 2, 3, 4, 5, 6)`) en drukken deze af naar het log. Wanneer je de code draait kom je erachter dat de afgedrukte lijst niet altijd gesorteerd is!. Dit kan je verrassen, zeker omdat de lijst soms gesorteerd is afgedrukt en soms niet. Dit wordt niet deterministisch gedrag genoemd en is het resultaat van een behoorlijk naar probleem genaamd race conditie. Het probleem komt doordat de tweede lus de lijst ook manipuleert (in dit geval door elkaar schudden). Tegen de tijd dat de lijst wordt afgedrukt is deze soms net gesorteerd en soms net geschud. Beide lussen ‘racen’ om iets anders te doen met dezelfde variabele en elke keer ‘wint’ er een andere lus.

Er zijn hiervoor twee oplossingen. Ten eerste, gebruik dezelfde variabele niet in meerdere live lussen of threads. Bijvoorbeeld: de volgende code drukt altijd een gesorteerde lijst omdat iedere live lus een aparte eigen variabele heeft:

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

Soms willen we echter dingen delen tussen threads. Bijvoorbeeld de huidige toonsoort, BPM, synth, etc. In deze gevallen is de oplossing om gebruik te maken van de speciale thread-safe state systemen in Sonic Pi via de functies `get` en `set`. Dit wordt verder beproken in sectie 10.

# 5.7 - Het Synchroniseren van Threads

Eens je het live coderen voldoende onder de knie hebt met een aantal functies en threads tezelfdertijd, dan heb je misschien opgemerkt dat het niet moeilijk is om een fout te maken in één van de threads die dodelijk kan zijn. Niet heel erg, want je kan makkelijk de thread terug herstarten door op afspelen te klikken. Maar als je de thread herstart is deze uit de maat met de originele threads.

## Overgenomen Tijd

Zoals we eerder hebben besproken, erven nieuwe threads gemaakt met `in_thread` alle instellingen van de bovenliggende thread. Dus ook de huidige tijd. Dit betekent dat de threads altijd synchroon met elkaar zijn als zij tegelijkertijd zijn gestart.

Wanneer je een thread op zich start, begint het met zijn eigen klok die waarschijnlijk niet in sync is met een van de andere actieve threads.

## Cue en Sync

Sonic Pi biedt een oplossing voor dit probleem met de functies ‘cue’ en ‘sync’.

‘cue’ laat ons toe, hartslag-berichten te sturen aan alle andere threads. Standaard zijn de andere threads niet geïnteresseerd in deze, en negeren deze hartslag-berichten. Je kan hun aandacht wel vragen met de functie ‘sync’.

Het belangrijkst om weten is dat ‘sync’ vergelijkbaar is met `sleep` in die zin dat het de huidige thread stopt voor een periode van tijd om om actief te zijn. Met `sleep` geef je echter aan hoe lang je wilt wachten terwijl je met ‘sync’ niet weet hoe lang je zal wachten - als ‘sync’ op de volgende ‘cue’ van een andere thread wacht die lang of kort kan wegblijven.

Laten we dit in detail bekijken:

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

Hier hebben we twee threads - één gedraagt zich als metronoom, zonder geluid te maken en zend elke maat enkel `:tick` hartslag-berichten uit. De tweede thread synchroniseerd op `tick` berichten en wanneer deze er één ontvangt, erft hij de `cue` tijd thread en blijft lopen.

Als gevolg zullen wij de ‘: drum_heavy_kick’ sample horen, precies op het moment dat de andere thread het `:tick` bericht uitzend, zelfs als de twee threads niet met de uitvoering ervan op hetzelfde moment beginnen:

    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

Die ondeugende `sleep` aanroep zou doorgaans de tweede thread uit fase laten lopen met de éérste. Als we echter `cue` en `sync` gebruiken, synchroniseren we automatisch alle lopende threads die toevallige verschuivingen in timing omzeilen.

## Cue Namen

Je mag eender welke naam gebruiken voor jouw `cue` berichten, niet enkel `:tick`. Je hoeft er alleen voor de zorgen dat alle threads op de correcte naam `sync`-en, anders gaan ze voor eeuwig wachten (of tot je op de stopknopstop klikt tenminste).

Laten we met en paar `cue` namen spelen:

    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

Hier hebben we een hoofd `cue` loop die random de heartbeat namen `:foo`, `:bar` or `:baz`uitzend. We hebben ook drie loop threads die elk onafhankelijk op één van die namen synct en daarbij een verschillende sample afspeeld. Het netto effect is dat we elke 0.5 beat een klank horen als wordt elk van deze 0.5 `sync` threads random ge-synct wordt met de `cue` thread en zijn sample speelt.

Dit werkt natuurlijk ook als jen de threads omgekeerd ordend omdat de`sync` threads gewoon op de volgende `cue` zitten wachten.

# 6 - Studio FX

Een van de meest lonende en leuke aspecten van Sonic Pi is de mogelijkheid om gemakkelijk studio-effecten aan uw geluiden toe te voegen . Bijvoorbeeld, op sommige delen van je muziekstuk een reverb toevoegen, of wat echo of misschien zelfs distortion op je wobbelende basslijnen.

Sonic Pi biedt een erg simpele, doch krachtige manier om effecten toe te voegen. Je kan deze zelfs in een ketting aan elkaar schakelen (dus kan je je klanken doogeven via distortion, dan echo-delay en dan reverb) en de effect-modules apart besturen (op een vergelijkbare manier dat je dat met de parameters van een synth of sampler zou doen). Je kan zelfs de opties modifiëren terwijl deze nog steeds loopt. Dus, bijvoorbeeld, je zou de reverb op je bas kunnen verhogen terwijl de track loopt…

## Gitaar Pedalen

Als dit allemaal een beetje ingewikkeld klinkt, maak je geen zorgen. Eens je hiermee een beetje speelt, zal het allemaal duidelijk worden. Maar voor je eraan begint, moet je weten dat het een werkt zoals bij gitaar effecten pedalen. Er zijn verschillende effect-pedalen te koop. Sommigen voegen een reverb-klank toe, andere distortion enz. Een gitarist zal zij of haar gitaar in één van de effect-pedalen pluggen, bv. distortion, en zal dan bvb een reverb effect in de uitgang van de eerste pedaal pluggen om het geluid door te schakelen (chain=ketting). De uitgang van de reverb-pedaal kan dan in de versterker geplugt worden:

    Gitaar -> Distortion -> Reverb -> Amplifier (Versterker)

Dit heet FX chaining. Sonic Pi ondersteunt precies dit. Bovendien heeft elke pedaal vaak wijzerplaten en schuifregelaars zodat je kan bepalen hoeveel distortion, reverb, echo enz je kan toepassen. Sonic Pi ondersteunt ook dit soort controle. Tot slot kan je je bvb gitaristen voorstellen en dat iemand anders met de FX-besturingselementen speelt, terwijl zij aan het spelen zijn. Sonic Pi ondersteunt dit ook- maar in plaats van dat iemand anders dingen voor jou controleert, doet de computer dit.

Laten we FX verkennen!

# 6.1 - FX Toevoegen

In deze sectie zullen we naar een paar Effecten kijken : reverb en echo. We zullen zien hoe ze te gebruiken, hoe hun opts te besturen en hoe ze te chainen.

Sonic Pi’s FX systeem maakt gebruik van blokken. Dus als je die niet hebt gelezen in sectie 5.1 Kan je hier snel naar kijken en kom dan naar hier terug.

## Reverb

Als we reverb willen gebruiken schrijven we `with_fx :reverb` als speciale code naar ons blok als volgt:

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

Speel deze code nu en hoor dat deze met reverb wordt gespeeld. Dat klinkt goed, niet?Alles klinkt vrij aardig met een reverb.

Laten we nu kijken wat er gebeurt als we buiten het do/end blok code hebben:

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

Merk op hoe de laatste `play 55` niet met reverb gespeeld wordt. Dit is omdat het buiten het do/end blok staat, en dus niet door de reverb FX gecapteerd kan worden.

Op dezelfde manier zullen klanken vòòr het do/end blok ook niet gecapteerd worden:

    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

## Echo

Er zijn veel effecten te kiezen. Wat dacht je van wat echo?

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

Één van de sterke punten van Sonic Pi’s FX blokken is dat je er opties aan kunt meegeven, vergelijkbaar met de opts die we al met `play` en `sample` hebben gezien. Een plezante echo opt om mee te spelen is `phase:` die de duurtijd van een echo in tellen (Beats) weergeeft. Laat ons even de echo vertragen:

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

Laten we de echo sneller maken:

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

Laat ons de echo over een langere tijd uitfaden door de `decay:` tijd in te stellen naar 8 beats:

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

## Effecten nesten

Een van de krachtigste aspecten van de FX-blokken is dat u hen kunt nesten. Hierdoor kan je heel gemakkelijk een FX keten samenstellen. Bijvoorbeeld, wat als je wat code met echo wilde spelen en vervolgens met een reverb? Gemakkelijk, zet de één gewoon in de andere:

    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

Denk aan de audio als zou deze van binnenuit stromen. Het geluid van alle code binnen het binnenste do/end blok zoals ‘play 50’ wordt eerst verzonden naar de echo FX en het geluid van de echo FX wordt op zijn beurt verstuurd naar de reverb FX.

We kunnen heel diep nesten en deze gebruiken voor maffe resultaten. Maar wees hierbij gewaarschuwd, want de FX kunnen veel cpu gebruiken wanneer u effectief meerdere effecten nest die gelijktijdig worden uitgevoerd. Wees dus spaarzaam op uw gebruik van effecten zeker op laag aangedreven platforms zoals Raspberry Pi.

## Effecten ontdekken

Sonic Pi wordt met een groot aantal effecten geleverd om mee te spelen. Als j wil weten welke er beschikbaar zijn, klik op FX in het linkeruiteinde van het help-systeem en je zal een lijst van beschikbare opties zien. Hier is een lijst van enkele van mijn favorieten:

wobble, reverb, echo, distortion, slicer

Doe nu maar eens goed gek en zet overal effecten op voor wat verbazingwekkende nieuwe geluiden!

# 6.2 - FX in de praktijk

Hoewel ze eenvoudig aan de buitenkant lijken, zijn effecten best complexe beesten intern. Hun eenvoud verleid mensen ertoe ze te gaan overgebruiken. Dit kan goed gaan op een krachtige machine, maar als je zoals ik een Raspberry Pi gebruikt om mee te jammen, met je voorzichtig zijn met de gevraagde werkkracht als je zeker wil zijn van een goede flow van jouw beats.

Bekijk even deze code:

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

In deze code spelen we noot 60 met een zeer korte release tijd, dus een korte noot. We willen ook reverb, dus hebben we die in een reverb blok gewikkeld. Dat gaat goed. Behalve…

Laten we eens kijken wat de code doet. Vooraleerst hebben we een `loop` wat betekent dat al wat hierin zit voor eeuwig wordt herhaald. Vervolgens hebben we een `with_fx` blok. Dit betekent dat we een nieuwe reverb FX zullen creëren *elke keer de loop opnieuw aan zijn beginpositie komt *. Dit is alsof we een extra FX reverb pedaal zouden bijkrijgen, elke keer dat je aan een snaar van een gitaar plukt. Het is wel cool dat je dit kunt doen, maar het is niet altijd wat je wilt. Deze code zal bijvoorbeeld moeite hebben mooi te draaien op een Raspberry Pi. Want al het werk om de reverb te vormen, en het wachten naar het moment dat deze moet stoppen en weer weggedaan moet worden wordt allemaal voor jou gedaan door de `with_fx`, maar dat vraagt CPU kracht die kostbaar kan zijn.

Hoe maken we deze meer vergelijkbaar met een traditionele opstelling waar onze gitarist slechts één reverb-pedaal heeft waardoor alle klanken passeren? Eenvoudig:

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

We zetten onze loop binnen het blok ‘with_fx’. Op deze manier maken wij slechts een enkele reverb voor alle noten die gespeeld worden in onze loop. Deze code is een stuk efficiënter en zou prima werken op een Raspberry Pi.

Een compromis is het gebruik van ‘with_fx’ buiten van de herhaling binnen een loop:

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

Op deze manier hebben we de ‘with_fx’ uit het binnenste deel van de `loop` gehaald en nu creëren we een nieuwe reverb elke 16 noten.

Deze situatie gaat in ons werk zo dikwijls terugkeren dat `with_fx` deze met een opt ondersteunt die dat zelf doet zonder de `16.times` blok te hoeven schrijven:

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

In de voorbeelden van `reps 16` en `16.times do` zullen zich beiden identiek gedragen. De `reps: 16` herhalen in wezen de code in het `do/end` blok 16 keer zodat u hen beide door elkaar kunt gebruiken en je kies gewoon de manier die voor jou het beste voelt.

Onthou, er zijn geen misstappen, enkel mogelijkheden. Echter, sommige benaderingen zullen een andere klank of een ander performant karakter hebben. Dus speel een beetje met deze verschillende benaderingen en gebruik diegene het best bij jou past en die het best samengaan met de beperkingen van de prestaties van het platform dat je gebruikt.

# 7 - De controle over lopende klank

Tot nu toe hebben we gekeken hoe je synths en samples kunt activeren, en ook hun standaard opties zoals amplitude, pan, envelop-instellingen en meer te wijzigen. Elk geactiveerd geluid is wezenlijk haar eigen geluid, met een eigen lijst van opties ingesteld voor de duur van de klank.

Zou het ook niet gaaf zijn dat als je dit geluid zou kunnen veranderen terwijl het nog steeds speelt, zoals je misschien een snaar van een gitaar zou buigen terwijl deze nog trilt?

Je hebt geluk- deze sectie gaat precies daarover.

# 7.1 - Lopende Synths Contoleren

Tot nu toe hebben we onszelf alleen bezig gehouden met de triggering van nieuwe drumklanken en FX. Sonic Pi geeft ons echter de mogelijkheid op het manipuleren en controleren van de momenteel lopende klanken. We doen dit door middel van een variabele die een verwijzing naar een synthesizer opvangt:

    s = play 60, release: 5

Hier hebben we de variabele van een run-local waarmee de synth noot 60 speelt. Merk op dat dit een run-local is - je kan geen toegang hebben tot deze vanaf een andere uitvoering zoals bij functies.

Eens we `s` hebben, kunnen we deze beginnen tweaken via de `control` functie:

    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

Wat je bij deze moet opmerken is dat wij hier geen 4 verschillende synths triggeren - maar slechts één synth triggeren om dan de toonhoogte 3 keer te wijzigen achteraf, terwijl deze wordt afgespeeld.

We kunnen iedere standaard opt doorgeven om `controle` over te hebben, zodat je `amp:`, `cutoff:` or `pan:´ kan controllen.

## Niet-Control-bare Opties

Sommige opts kunnen niet gecontrold worden eens de synth gestart is. Dis is het geval voor alle ADSR envelop parameters. Je kan uitzoeken welke opts gecontrold kunnen worden door naar hun documentie te kijken in het hulp systeem. Als de de documentatie zegt Can not be changed once set, dan weet je dat het niet mogelijk is om de opt te controllen als de synth al loopt.

# 7.2 - FX Controllen

Het is ook mogelijk om FX te controllen, hoewel dit op een iets andere manier wordt bereikt:

    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

In plaats van een variabele, gebruiken we de sluisteken parameters van het do/end blok. Binnen de `|` staafjes , moeten we een unieke naam voor onze lopende FX opgeven die we vervolgens verwijzen vanuit het do/end blok. Dit gedrag is identiek aan het gebruik van geparametriseerde functies.

Ga nu enkele synths en FX Controllen !

# 7.3 - Glijdende Opties

Tijdens het verkennen van de synth en FX opties is het je misschien opgevallen dat er een aantal opts zijn die eindigen op `_slide`. Je hebt deze misschien ook proberen oproepen en daarmee opgemerkt dat zij geen effect hebben. Dat is omdat zij geen normale parameters zijn, het zijn speciale opts die enkel werken wanneer je synths controlt zoals beschreven in de voorgaande sectie.

Beschouw het volgende voorbeeld:

    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

Hier hoor je de toonhoogte van de synth onmiddellijk wijzigen op elke `control` appèl . Wij willen echter dat de toonhoogte slide (glijdt) tussen de veranderingen. Vermits we de `note:` parameter controllen, om slide toe te voegen, moeten we de parameter ‘note_slide’ van de synth instellen:

    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

Nu horen we de de noten buigen tussen de `control`aanroep. Dat klinkt lekker, niet? Je kan de slide versnellen door een kortere tijd te gebruiken zoals `note_slide: 0.2` of vertragen door een langere slide time in te stellen.

Elke parameter die controlt kan worden heeft een identieke parameter ‘_slide’ voor jou om mee te spelen.

## Slide-en blijft plakken

Zodra u hebt een parameter ‘_slide’ ingesteld op een lopende synth, zal het worden onthoudenen telkens wanneer u de bijbehorende parameter slide gebruikt . Als je de slide wilt stoppen moet je de waarde ‘_slide’ op 0 instellen voor de volgende oproep van `control`.

## Sliding FX Opts

Het is ook mogelijk FX opts te slide-en:

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

Veel plezier met het rond slide-en van zaken voor een vloeiende overgang en een vlotte control…

# 8 - Datastructuren

Een zeer nuttig hulpmiddel in de gereedschapskist van een programmeur is een datastructuur.

Soms wil je meer dan één ding kunnen representeren en gebruiken. Zo kan je het bijvoorbeeld op en moment nodig vinden om een serie noten achter elkaar te spelen,de één na de andere. Programmeertalen hebben datastructuren die jou dit toelaten.

Er zijn vele spannende en exotische gegevensstructuren beschikbaar voor programmeurs - en veel mensen zijn nog altijd bezig met het uitvinden van nieuwe. Maar momenteel gaan we enkel een zeer eenvoudige gegevensstructuur beschouwen- de lijst.

Laten we dit eens in detail bekijken. We zullen zijn basisvorm behandelen en ook hoe lijsten kunnen worden gebruikt voor toonladders en akkoorden.

# 8.1 - Lijsten

In deze sectie zullen we een kijkje nemen naar een datastructuur die zeer nuttig kan zijn - de lijst. We hebben dit al kort gezien in het gedeelte over randomiseren, wanneer we willekeurig uit een lijst van noten kiezen om te spelen:

    play choose([50, 55, 62])

In deze sectie verkennen we om ook akkoorden en toonladders door lijsten te laten vertegenwoordigen. Eerste recapituleren we even hoe we een snaar kunnen bespelen. Denk eraan dat als we geen gebruik maken van `sleep` we alle klanken tezelfdertijd horen :

    play 52
    play 55
    play 59

Laten we eens kijken naar andere manieren om deze code weer te geven.

## Afspelen van een lijst

Een optie zou kunnen zijn om alle noten in een lijst te zeten `[52, 55, 59]`. Onze vriendschappelijke `play` functie is slim genoeg om een lijst van noten te kunnen spelen. Probeer maar:

    play [52, 55, 59]

Ooh, dat is al aangenamer om lezen. Een lijst met noten afspelen weerhoud je niet om de gewoonlijke parameters te gaan gebruiken:

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

Natuurlijk kan je ook de traditionele benaming van de noten gebruiken ipv. de MIDI nummers:

    play [:E3, :G3, :B3]

De gelukkigen onder jullie die wat muziektheorie hebben geleerd, hebben het akkoord E Mineur in het 3de octaaf herkend.

## Toegang tot een lijst

Een andere zeer nuttige functie van een lijst is de mogelijkheid om er informatie uit te krijgen. Dit klinkt misschien een beetje vreemd, maar het is niet ingewikkelder dan iemand die jou vraagt een boek op pagina 23 open te slaan. Bij een lijst, zou je kunnen zeggen: wat is het element op index 23? Het vreemde alleen is dat programmeer indexen meestal bij 0 beginnen en niet 1.

Met lijst indexen tellen we niet 1,2,3… maar 0,1,2…

Laten we dit een beetje meer in detail bekijken. Neem een kijkje naar deze lijst:

    [52, 55, 59]

Dit is niet onoverkomelijk. Wat is nu het tweede element in de lijst? Dat is `55` natuurlijk ja. Dat was makkelijk. Laten we eens kijken of de computer zover kunnen krijgen om dit voor ons te doen:

    puts [52, 55, 59][1]

OK, dat ziet er misschien een beetje raar als je nog nooit zoiets gezien hebt. Geloof me maar, het is niet te moeilijk. Er zijn drie onderdelen naar de regel erboven: het woord `puts`, onze lijst ‘ 52, 55, 59’ en onze index ‘[1]’. Ten eerste: we zeggen `puts` omdat we willen dat Sonic Pi het antwoord voor ons in het logboek afdrukt . Vervolgens geven we het onze lijst, en tenslotte vraagt onze index naarr het tweede element. We moeten onze index omringen met vierkante haken en omdat tellen bij ‘0’ begint, is de index voor het tweede element `1`. Kijk:

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

Probeer de code uit te voeren ´puts [52, 55, 59] [1]`en je ziet` 55´ in het logboek opduiken. Zet de index ´1´ om in andere indexen, probeer langere lijsten en denk na over hoe u een lijst in uw volgende code jam kunt gebruiken. Welke muzikale structuren kunnen bijvoorbeeld worden weergegeven als een reeks getallen…

# 8.2 - Akkoorden

Sonic Pi heeft ingebouwde ondersteuning voor akkoordnamen die lijsten zullen weergeven. Probeer dit voor jezelf:

    play chord(:E3, :minor)

Nu komen we er. Dit ziet er veel beter uit dan de rauwe lijst (en is makkelijker te lezen voor andere mensen). Welke andere akkoorden ondersteund Sonic Pi nog? Wel, een hoop. Probeer wat van deze:

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

## Arpeggio ‘s

We kunnen gemakkelijk akkoorden in arpeggio’s omzetten met de functie ‘play_pattern’:

    play_pattern chord(:E3, :m7)

Ok, dit is niet zo fijn- het speelde het echt te traag. `play_pattern` zal elke noot van de lijst apart afspelen met een rust van `sleep 1` tussen elke oproep naar `play`. We kunnen de functie `play_pattern_timed` gebruiken om een eigen timing aan te geven en het wat sneller te laten gaan:

    play_pattern_timed chord(:E3, :m7), 0.25

We kunnen zelfs een lijst met tijden doorgeven, welke als een tijdscirkel zullen worden behandeld:

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

Dit is gelijk aan:

    play 52
    sleep 0.25
    play 55
    sleep 0.5
    play 59
    sleep 0.25
    play 62
    sleep 0.5
    play 66
    sleep 0.25
    play 69
    sleep 0.5
    play 73

Welke wil je liever schrijven?

# 8.3 - Toonladders

Sonic Pi geeft ondersteuning aan een breed scala van toonladders. Wat dacht je van de toonladder C3 majeur?

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

We kunnen zelfs meer octaven vragen:

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

Wat dacht je van deze noten in een pentatonische toonladder?

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

## Random noten

Akkoorden en toonladders zijn een goede manieren om een willekeurige keuze tot iets zinvols te beperken. Speel met dit voorbeeld dat willekeurige noten uitkiest van het akkoord E3 mineur:

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

Probeer verschillende akkoordnamen en cutoff in te geven.

## Akkoorden en toonladders ontdekken

Om erachter te komen welke toonladders en akkoorden worden ondersteund door Sonic Pi klikt u de knop Lang op het linkeruiteinde van deze tutorial en kies vervolgens chord of scale in de lijst van de API. Scroll In de informatie van het hoofdpaneel naar beneden totdat u een lange lijst van akkoorden of schalen ziet (afhankelijk van welke u zoekt).

Veel plezier en vergeet niet: er zijn geen fouten, alleen kansen.

# 8.4 - Ringen

Een interessante draai aan standaard lijsten zijn ringen. Als u wat programmeren weet, ben je misschien al ring buffers of ring array’s tegengekomen. Hier gaan we gewoon voor ring - het is kort en simpel.

In de vorige sectie over lijsten zagen we al hoe we elementen door het indexeer mechanisme uit hen konden halen:

    puts [52, 55, 59][1]

War gebeurd er nu als je `100` wil indexeren? Wel er is duidelijk geen element bij index 100 daar de lijst enkel drie elementen bevat. Dus Sonic Pi zal `nil` weergeven, wat niets betekent.

Stel nu even dat je een teller hebt en dat deze jouw huidige beat is die in snelheid toeneemt. Lat ons deze teller en lijst aanmaken:

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

We kunnen nu onze teller gebruiken om toegang te krijgen tot een noot in onze lijst:

    puts notes[counter]

Geweldig, we hebben `52`. Nu, laten we onze teller verhogen en krijg een andere noot:

    counter = (inc counter)
    puts notes[counter]

Super, we krijgen nu `55` en als wij het opnieuw doen krijgen we `59`. Als wij het nogmaals doen, raken onze cijfer op in onze lijst en krijgen we `nil`. Wat als we bij het begin van de lijst weer willen beginnen? Dit is wat waar ringen voor zijn.

## Ringen maken

We kunnen ringen op twee manieren maken. We kunnen de `ring` functie gebruiken met de elementen van de ring als parameters:

    (ring 52, 55, 59)

Of we kunnen een normale lijst nemen en deze naar een ring omzetten door naar deze een `.ring` bericht te zenden :

    [52, 55, 59].ring

## Ringen Indexeren

Eens we een ring hebben, kan je deze op exact de zelfde manier als gewone lijsten gebruiken met uitzondering dat je indexen kunt gebruiken die negatief zijn of groter dan de grootte van de ring, en altijd naar één van de elementen van de ring zullen omslaan:

    (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

## Ringen Gebruiken

Laten we zeggen dat we een variabele gebruiken om het nummer van de huidige beat te vertegenwoordigen. We kunnen dit als een index in onze ring gebruiken om noten te halen om te spelen of release tijden of alles wat nuttig zou kunnen zijn en we hebben opgeslagen in onze ring ongeacht het beat nummer dat we momenteel hebben.

## Toonladders en Akkoorden zijn ringen

Handig om weten is dat de lijsten door `scale` en de `chord` opgeroepen, ook ringen zijn en jou toelaten willekeurige indexen te openen.

## Ring Bouwers

Naast de `ring` zijn er een aantal andere functies die een ring voor ons zullen bouwen.

`range`nodigt je uit om een start en een eindpositie op te geven en de grootte van de stappen. `bools` laten het gebruik van `1`s en `0`s om beknopte booleaans te vertegenwoordigen. `knit` laat jou een sequentie met repeterende waarden breien. `spread` creëert een ring van een boleaanse met een Euclidische distributie.

Neem een kijkje naar hun respectievelijke documentatie voor meer informatie hierover.

# 8.5 - Ring Kettingen

Als toevoeging tot de bouwers zoals `range`en `spread`is het manipuleren van bestaande ringen, een andere manier om nieuwe ringen te maken.

## Ketting Commando’s

Neem deze eenvoudige ring om dit te verkennen:

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

Wat als we deze andersom willen? Dan kunnen we het chain commando `.reverse nemen om de ring om te draaien:

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

En wat als we de eerste drie waarden van de ring willen nemen?

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

En wat als we de ring willen verschuiven?

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

## Meerdere Kettingen

Dit is al een krachtige manier om nieuwe ringen te creëren. De echte kracht komt wanneer je een paar van deze opdrachten samen chaint.

Wat denk je ervan de ring te shuffelen, 1 element te laten vallen en vervolgens de volgende 3 te nemen?

Laten we dit in fasen doen:

`(ring 10, 20, 30, 40, 50)` - our initial ring `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)` `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)` `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`

Kan je nu zien dat we een lange ketting van deze methoden kunnen gebruiken door deze bij elkaar te plakken. We kunnen deze in eender welke volgorde combineren en ontwikkellen hierbij een uiterst rijke en krachtige manier om nieuwe ringen van bestaande ringen te creëren.

## Onveranderbaarheid

Deze ringen hebben een krachtige en belangrijke eigenschap. Ze zijn onveranderlijk wat betekent dat je ze niet kunt veranderen. Dit betekent dat de chaining methode die in deze sectie beschreven word ringen niet veranderd maar eerder nieuwe ringen maakt. Dit betekent dat u vrij bent om te ringen te delen met threads en je hen kan beginnen chainen binnen een thread met de wetenschap dat je geen andere thread zal beïnvloeden die gebruik maakt van dezelfde ring.

## Beschikbare Chain Methoden

Hier is een lijst van de beschikbare chain methoden voor jou om mee te spelen:

‘.reverse’ - geeft een omgekeerde versie van de ring ‘.sort’ - creëert een gesorteerde versie van de ring ‘.shuffle’ - creëert een geshuffelde versie van de ring ‘.pick(3)’ - geeft een ring met de resultaten van de aanroep `.choose` 3 keer ‘.pick(3)’ - geeft een ring met de resultaten van de aanroep `.choose` 3 keer ‘.take(5)’ - geeft als resultaat een nieuwe ring die alleen eerste 5 elementen bevat ‘.drop(3)’ - geeft als resultaat een nieuwe ring met alles behalve de eerste 3 elementen ‘.butlast’ - geeft als resultaat een nieuwe ring maar ontbreekt het laatste element ‘.drop_last(3)’ - geeft als resultaat een nieuwe ring maar de laatste 3 elementen ontbreken ‘.take_last(6)’-geeft als resultaat een nieuwe ring met alleen de laatste 6 elementen ‘.stretch(2)’ - herhaald tweemaal elk element in de ring ‘.repeat(3)’ - herhaalt de hele ring 3 keer ‘.mirror’ - voegt de ring naar een omgekeerde versie van zichzelf toe ‘.reflect’ - hetzelfde als spiegel maar middelste waarde wordt niet gedupliceerd `.scale(2)`- geeft een nieuwe ring met alle elementen, maal 2 (van uitgegaan dat ring alleen cijfers bevat)

Natuurlijk, kan je in deze chain methoden ook andere cijfers gebruiken! Dus voel je vrij om `.drop(5)` in plaats van `.drop(3)` als je de eerste 5 elementen wilt laten vallen.

# 9 - Live Coderen

Éen van de meest opwindende aspecten van Sonic Pi is dat je live code kan schrijven en deze veranderd om muziek te spelen, net zoals je zou optreden met je gitaar. Een voordeel van deze aanpak is dat je meer feedback krijgt terwijl je componeert (je kaan een simpele code loop laten lopen en deze tweaken tot deze perfect klinkt). Het belangrijkste voordeel is echter dat u Sonic Pi op het podium mee kunt nemen en kan optreden.

In deze sectie zullen we de fundamenten bespreken hoe je je statische code kan omvormen tot een dynamische voorstelling.

Zit je goed? …

# 9.1 - Live Coderen

Nu hebben we genoeg geleerd en kan het echte plezier beginnen. In deze sectie trekken we uit alle vorige secties zaken die jou laten zien hoe je je composities tot live muziek kan maken en ze in een voorstelling kan omtoveren. Daarvoor hebben we 3 hoofd ingrediënten nodig:

Code kunnen schrijven dat geluiden kan voortbrengen - CHECK! Functies kunnen schrijven - CHECK! (benoemde) Threads kunnen gebruiken - CHECK!

We gaan aan de slag. We coderen onze eerste geluiden. We moeten eerst een functie hebben met de code die we willen spelen. Laten we eenvoudig beginnen. Wij willen ook loops oproepen die in een thread functioneren:

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

Als dat een beetje te ingewikkeld voor je lijkt, ga dan even terug en herlees de passages over functies en threads. Het is niet al te ingewikkeld nu je je al in deze zaken verdiept hebt.

Wat we hier hebben is een functiedefinitie dat gewoon noot 50 speelt en een beat slaapt. Vervolgens definiëren we een benoemde thread genaamd `:looper` die herhaaldelijk rond `my_loop` loopt.

Als u deze code uitvoert, zult je noot 50 altijd opnieuw en opnieuw horen spelen…

## Veranderingen aanbrengen

Nu, hier is waar de pret begint. Terwijl de code nog loopt wijzigen 50 naar een ander nummer, zeg 55, druk nogmaals op de knop afspelen. Woah! Het veranderd! Live!

Het heeft geen nieuwe laag toegevoegd omdat we benoemde threads gebruiken, die voor elke naam één thread toestaat. De klank veranderde ook omdat we de functie hebben geherdefinieerd. We gaven `:my_loop` een nieuwe definitie. Wanneer de `:looper` thread rond Loopt riep deze de nieuwe definitie op.

Probeer het opnieuw te wijzigen, verander de noot, de rusttijd. Hoe zit het met het toevoegen van het `use_synth` statement? Verander het bijvoorbeeld naar:

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

Nu het klinkt erg interessant, maar we kunnen het verder verlevendigen. In plaats van dezelfde noot opnieuw en opnieuw te spelen, speel een akkoord:

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

Wat denk je van random noten van het akkoord te spelen:

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

Of met behulp van een willekeurige cutoff waarde:

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

Ten slotte, voeg enkele drums toe:

    define :my_loop 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

Nu word het steeds spannender!

Maar voor je recht springt en je begint te live coden met functies en threads, stop met wat je doet en lees de volgende sectie over `live_loop` wat de manier van coderen in Sonic Pi voor eeuwig zal veranderen…

# 9.2 - Live Loops

OK, dus dit gedeelte van de handleiding is de echte parel. Als je maar één gedeelte zou kunnen lezen, zou het deze moeten zijn. Als je de vorige sectie van Live codering grondbeginselen leest, is ‘live_loop’ een eenvoudige manier om precies dat te bereiken, maar zonder zo veel code te hoeven schrijven.

Als je de vorige sectie niet gelezen hebt, `live_loop` is de beste manier om met Sonic Pi te jammen.

Laten we hiermee even spelen. Schrijf het volgende in een nieuwe buffer:

    live_loop :foo do
      play 60
      sleep 1
    end

Druk op de afspeel knop. Je hoort elke tel een zelfde basis bliep. Niks opwindend aan. Maar druk nog niet op Stop. Verander de `60` naar `65` en druk terug op Afspelen.

Woeha! Het veranderde automatisch zonder een tel te missen. Dit is Live Coding.

Waarom deze niet veranderen aar iets meer Bass-achtig? Gewoon je code updaten terwijl het speelt:

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

Sla Afspelen aan.

Laten we de cutoff wat rond-bewegen:

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

Sla Afspelen opnieuw aan.

Voeg wat drums toe:

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

Verander de noot van `e1` naar `c1`:

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

Stop nu met naar mij te luisteren en ga zelf aan de slag! Veel plezier!

# 9.3 - Meerdere Live Loops

Beschouw even de volgende code:

    live_loop :foo do
      play 50
      sleep 1
    end

Je kan je al afgevraagd hebben waarom het de naam `: foo` moet zijn. Deze naam is belangrijk, omdat het betekent dat deze live loop van de andere live loops verschilt.

Er kunnen nooit twee live loops met de zelfde naam afspelen.

Dit betekent dat als we willen dat meerdere live loops gelijktijdig willen uit voeren, moeten we ze gewoon een andere naam geven:

    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

Je kan nu elke live loop onafhankelijk van elkaar wijzigen en updaten en het werkt gewoon allemaal.

## Synchroniseren van Live Loops

Wat je misschien al opgevallen is is dat live loops automatisch met het thread cue mechanisme werkt dat we al verkend hebben. Elke keer een live loop afspeelt genereert deze een nieuw cue gebeuren met de live loop’s naam. We kunnen daarom op deze cue’s sync-en om ons ervan te verzekeren dat onze loops in sync lopen zonder we daarvoor iets moeten gaan stoppen.

Beschouw even deze slecht gesyncte code:

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

Laten we eens kijken als we de timing en synchronisatie kunnen verhelpen zonder deze te stoppen. Laten we eerst de `:foo` loop fixen en de sleep factor 1 veranderen naar `0.5` :

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

We zijn nog niet helemaal klaar -je zult merken dat de beats niet helemaal correct samenlopen. Dit komt omdat de loops uit fase spelen. Laten we dat verhelpen door de ene aan de andere te synchroniseren:

    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, nu is alles perfect in tijd - allemaal zonder te stoppen.

Ga nu door met je live code en live loops!

# 9.4 - Ticking

Soms heb je best veel werk, zo lijkt het, wanneer er veel code door een ring loopt. Je zal noten in rings steken voor melodieën, rusttijden (sleep) bij ritmes, akkoordenschema’s, variaties op het timbre, enz. enz.

## Tick Ringen

Sonic Pi biedt een zeer handig hulpmiddel voor het werken met ringen binnen `live_loop`s. Het heet het tick systeem. In de sectie over de ringen spraken we over de teller die constant verhoogt, zoals een weergave van de huidige tel . Tick voert het zelfde idee uit. Het biedt u de mogelijkheid om te doorheen ringen te tikken. Laten we eens kijken naar een voorbeeld:

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

Dit is gelijk aan:

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

Hier nemen we de pentatonische toonladder E3 mineur en ticking doorheen elk element. Dit wordt gedaan door `.tick` toe te voegen aan het einde van de verklaring van de toonladder. De tick is lokaal voor de live loop, dus elke live loop kan zijn eigen onafhankelijke tick hebben:

    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

## Tick

U kunt ook `tick` als een standaard fn aanroepen en de waarde gebruiken als een index:

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

Het is veel leuker om `.tick` op het einde aan te roepen. de `.tick` fn is als je je dingen wil verbeelden met de tick waarde en voor wanneer je ticks wil gebruiken voor andere dingen dan in ringen te indexeren.

## Kijk

De magische van tick is dat niet alleen het resultaat geeft van een nieuwe index (of de waarde van de ring op die index) ook zorgt het ervoor dat de volgende keer dat u tick aanroept, dit de volgende waarde zal zijn. Neem een kijkje naar de voorbeelden in de docs `tick` voor de vele manieren om hiermee te werken. Nu is het echter belangrijk erop te wijzen dat je soms gewoon wil kijken naar de huidige waarde van de `tick` maar deze niet te verhogen. Deze optie is beschikbaar via de `look` fn. U kunt `look` oproepen zoals een standaard fn of door toevoeging van `look` aan het einde van een ring.

## Ticks Benoemen

En nog dit, soms heb je meer dan één tick per live loop nodig. Dat kan je door je tick een naam te geven:

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

Hier gebruiken we twee ticks: één voor de te spelen noten en een andere voor de rusttijd (sleep). Vermits deze alle twee in dezelfde live loop zitten, moeten we ze een unieke naam geven om hen te kunnen onderscheiden. Hier gaat het net zoals een `live_loop` benoemen, we geven een symbool door, voorafgegaan door een `:`. In het voorgaande voorbeeld noemden we één tick `:foo`en een andere `:bar`. Als we naar dezen willen kijken ( `look`), moeten we ook de naam van de tick doorgeven aan `look`.

## Maak het niet te ingewikkeld

De grote kracht van het tick systeem is niet behulpzaam als beginner. Probeer niet alles uit deze sectie. Focus op een tick in één enkele ring. Dit geeft de grootste voldoening en is het minst gekunsteld tick-en door ringen in jouw `live_loop`s.

Neem een kijkje naar de documentatie ‘Tick’ waar nuttige voorbeelden te vinden zijn. Nog een leuke tick verder!

# 10 - Tijd toestand

Vaak is het nuttig om informatie te delen over meerder threads of live lussen. Je zou bijvoorbeeld de huidige toonsoort, BPM of meer abstracte concepten zoals de huidige ‘complexiteit’ (wat je potentieel op verschillende manieren interpreteerd in verschillende threads). We willen ook niet iets van ons bestaande garanties voor determinisme verliezen wanneer we dit doen. In andere woorden, we willen nog steeds code met andere kunnen delen en exact weten wat ze horen wanneer het wordt uitgevoerd. Aan het einde van sectie 5.6 van deze tutorial wordt kort besproken waarom we geen variabelen zouden moeten gebruiken om informatie te delen tussen threads vanwege het verlies van determinisme (op hun beurt veroorzaakt door race condities).

De oplossing in Sonic Pi voor het probleem van een makkelijk model met globale variabelen op een deterministische wijze is door een vernieuwend systeem dat tijd toestand wordt genoemd. Dit kan complex en moeilijk klinken (in feite is programmeren met meerdere threads en een gedeeld geheugenmodel tipisch een onderwerp op universitair niveau). Echter, zoals je zult zien, net als het spelen van de eerste noot, * Sonic Pi maakt het onzetten eenvoudig om toestand te delen tussen threads* terwijl je programma’s nog steeds thread safe en deterministisch blijven.

Maak kennis met `get` en `set`…

# 10.1 - Set en get

Sonic Pi heeft een globaal memory model genaamd tijd toestand. De twee belangrijkste dingen die je ermee doet is informattie `zetten` (set) en `ophalen` (get). Laten we erin duiken…

## Set

Om informatie op te slaan in de tijd toestand hebben we twee dingen nodig:

de informatie die we willen opslaan, een unieke naam (sleutel) voor de informatie.

We willen bijvoorbeeld het getal `3000` opslaan met de sleutel `:intensiteit`. Dit is mogelijk door de `set` functie te gebruiken:

    set :intensiteit, 3000

We kunnen elke naam gebruiken voor onze sleutel. Wanneer informatie al was opgeslagen voor die sleutel, dan overschrijft de nieuwe `set` die:

    set :intensiteit, 1000
    set :intensiteit, 3000

In het bovenstaande voorbeeld hebben we beide getallen opgeslagen onder dezelfde sleutel. De laatste aanroep van `set` ‘wint’. Het getal dat gekoppeld is aan `:intensiteit` zal `3000` zijn omdat de eerste aanroep van `set` effectief wordt overschreven.

## Get

Om informatie op te halen uit de tijd toestand hebben we allen de sleuten nodig die werd gebruikt om voor `set`. In ons geval is dat `:intensiteit`. We hoeven alleen `get[:intensiteit]` aan te roepen wat we kunnen zien door het resultaat naar het log af te drukken:

    print get[:intensiteit] #=> print 3000

Merk op dat aanroepen van `get` informatie kunnen teruggeven die was ge`set` in de vorige uitvoering. Wanneer een stuk informatie is ge`set` is het beschikbaar totdat of de informatie is overschreven (net als de aanpassing van `:intensiteit` van de waarde `1000` naar `3000` hierboven) of Sonic Pi is afgesloten.

## Meerdere threads

Het belangrijkste voordeel van het tijd toestand systeem is dat het veilig gebruikt kan worden tussen meerdere threads of live lussen. Je kunt bijvoorbeeld een live lus hebben voor het zetten van informatie en een andere voor het ophalen:

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

Het leuke aan het gebruik van `get` en `set` tussen meerdere threads zoals hier is dat het altijd hetzelfde resultaat oplevert iedere keer dat je op uitvoeren drukt. Vooruit, probeer het. Kijk op je het volgende in je log krijgt:

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

Probeer het een paar keer uit te voeren, zie je wel, het is steeds hetzelfde. Dit is wat we deterministisch gerag noemen en het is werkelijk heel belangrijk wanneer we onze muziek als code willen delen en zeker willen weten dat de persoon die code afspeelt exact hetzelfde hoort als wat we wilden dat ze hoorden (net als een MP3 afpselen of een internet stream voor alle luisteraars hezelfde klinkt).

## Een simple deterministisch toestandssysteem

Eerder, in sectie 5.6, bespraken we waarom variabelen gebruiken over meerdere threads voor willekeurig gedrag kan zorgen. Daardoor is het betrouwbaar reproduceren zoals de volgende code niet mogelijk:

    ## Een voorbeeld van niet deterministisch gedrag
    ## (veroorzaakt door race condities veroorzaakt door meerdere
    ## live lussen die dezelfde variable manipuleren
    ## op hetzelfde moment).
    ##
    ## Wanneer je deze code uitvoert zul je opmerken
    ## dat de lijst die wordt afgedrukt
    ## niet altijd gesorteerd is
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :geschud do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :gesorteerd do
      a = a.sort
      sleep 0.5
      puts "gesorteerd: ", a
    end

Laten we kijken hoe dit eruit ziet wanneer we `get` en `set` gebruiken:

    ## Een voorbeeld van deterministisch gedrag
    ## (ondanks gelijktijdige toegang tot gedeelde toestand)
    ## door het gebruik van het tijd toestand systeem van Sonic Pi.
    ##
    ## Wanneer deze code wordt uitgevoerd is de lijst
    ## die wordt afgedrukt altijd gesorteerd!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :geschud do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :gesorteerd do
      set :a, get[:a].sort
      sleep 0.5
      puts "gesorteerd: ", get[:a]
    end

Merk op dat de code bijna identiek is aan de versie die de variabele gebruikt hiervoor. Echter wanneer je de code uitvoert gedraagt het zich zoals je zou verwachten met elk typisch stuk Sonic Pi code: het doet elke keer hetzelfde in dit geval dankzij het tijd toestand systeem.

Gebruik daarom wanneer je informatie deelt tussen live lussen en threads `get` en `set` in plaat van variabelen voor deterministisch en reproduceerbaar gedrag.

# 10.2 - Sync (synchroniseren)

Sectie 5.7 introduceerde de functies `cue` en `sync` om het synchroniseren van threads af te handelen. Wat niet werd uitgelegd is dat het het tijd toestand systeem is dat deze functionaliteit beschikbaar stelt. Eigenlijk is `set` een variatie op `cue` en bouwt voort op dezelfde kernfunctionaliteit: het toevoegen van informatie aan het tijd toestand systeem. Bovendien is `sync` ook zo ontworpen dat het naadloos samenwerkt met de tijd toestand - alle informatie die we van plan zijn op te slaan in de tijd toestand waarop we kunnen synchroniseren. Met andere woorden - * we `sync`-en op gebeurtenissen die nog moeten worden ingevoegd in de tijd toestand *.

## Wachten op gebeurtenissen

Laten we kort kijken naar hoe `sync` gebruikt wordt om op nieuwe gebeurtenissen te wachten die worden toegevoegd aan tijd toestand:

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

In dit voorbeeld maken we eerst een draad die wacht op een ‘:foo’-gebeurtenis die toegevoegd wordt aan de Time State. Nadat we deze draad aangekondigd hebben, slapen we twee slagen en dan zetten we (‘set’) ‘foo’ op ‘1’. Dat zorgt er vervolgens voor dat de ‘sync’ vrijgegeven wordt zodat op de volgende regel het ‘:ambi_lunar_land’-stukje geactiveerd wordt.

Let erop, dat ‘sync’ altijd wacht op toekomstige gebeurtenissen, en dat het de huidige draad blokkeert zolang die gebeurtenis nog niet opgetreden is. Bovendien erft het de logische tijd van de draad die hem geactiveerd heeft via de ‘set’ of ‘cue’, zodat het gebruikt kan worden om de tijd te synchroniseren.

## Doorgeven van waarde aan de toekomst

In het bovenstaande voorbeeld is ‘:bla’ op ‘1’ gezet om er vervolgens niets mee te doen. We kunnen de waarde ophalen van de thread door ‘sync’ aan te roepen:

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

Let erop, dat waarde die via ‘set’ en ‘cue’ doorgegeven worden ‘thread safe’ moeten zijn. Dat wil zeggen dat de waarden niet opeens gewijzigd mogen kunnen worden. Voorbeelden van toegestane waardetypes zijn onveranderlijke tekenreeksen (‘immutable strings’), getallen, symbolen of bevroren tekenreeksen (‘frozen strings’). Sonic Pi geeft een foutmelding als je een waarde gebruikt die niet aan die voorwaarde voldoet.

# 10.3 - Patroonherkenning

Wanneer je informatie haalt (‘get’) van de Time State of gegevens in de Time State vastlegd (‘set’), kun je ook complexere waarden gebruiken dan de basissymbolen zoals ‘:foo’ en ‘:bar’. Je kan bijvoorbeeld paden in een URL-stijl gebruiken zoals ‘/foo/bar/baz’. Zodra we zulke paden gaan gebruiken, kunnen we voordeel halen uit de slimme patroonherkenning van Sonic Pi, zodat we met vergelijkbare (‘similar’) in plaats van precies gelijke (‘identical’) paden kunnen halen (‘get’) en synchroniseren (‘sync’). Laten we eens kijken.

## Match any path segment

Let’s assume we want to wait for the next event that has three path segments:

    sync "/*/*/*"

This will match any Time State event with exactly three path segments, regardless of their names. For example:

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

However, it will not match paths with fewer or more path segments. The following will not match:

`cue "/bla/bar"` `cue "/bla/baz/quux/quaax"` `cue "/eggs"`

Each `*` means any content. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`

## Matching partial segments

foo

`cue "/bla/bar/baz"` `cue "/bla/baz/baz"` `cue "/bla/beans/baz"`

However, it wouldn’t match the following:

`cue "/bla/flibble/baz"` `cue "/bla/abaz/baz"` `cue "/bla/beans/baz/eggs"`

foo

## Matching Nested Path Segments

foo

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

## Matching Single Letters

You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:

`cue "/bla/bar/baz"` `cue "/goo/bar/baz"` `cue "/too/bar/baz"` `cue "/woo/bar/baz"`

## Matching Multiple Words

foo

`cue "/bla/bar/quux"` `cue "/bla/beans/quux"` `cue "/bla/eggs/quux"`

## Matching Multiple Letters

foo

`cue "/bla/aux/baz"` `cue "/bla/bux/baz"` `cue "/bla/cux/baz"`

foo

`cue "/bla/aux/baz"` `cue "/bla/bux/baz"` `cue "/bla/cux/baz"` `cue "/bla/dux/baz"` `cue "/bla/eux/baz"`

## Combining Matchers

When calling `sync` or `get` you are free to combine matchers in any order you see fit to powerfully match any Time State event created by `cue` or `set`. Let’s look at a crazy example:

    sample :loop_amen

## OSC Pattern Matching

For those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: http://opensoundcontrol.org/spec-1_0

# 11 - MIDI

Once you’ve mastered converting code to music, you might wonder - what’s next? Sometimes the constraints of working purely within Sonic Pi’s syntax and sound system can be exciting and put you into a new creative position. However, sometimes it is essential to break out of the code into the real world. We want two extra things:

To be able to convert actions in the real world into Sonic Pi events to code with To be able to use Sonic Pi’s strong timing model and semantics to control and manipulate objects in the real world

Luckily there’s a protocol that’s been around since the 80s that enables exactly this kind of interaction - MIDI. There’s an incredible number of external devices including keyboards, controllers, sequencers, and pro audio software that all support MIDI. We can use MIDI to receive data and also use it to send data.

Sonic Pi provides full support for the MIDI protocol enabling you to connect your live code to the real world. Let’s explore it further…

# 11.1 - MIDI In

In this section we will learn how to connect a MIDI controller to send events into Sonic Pi to control our synths and sounds. Go and grab a MIDI controller such as a keyboard or control surface and let’s get physical!

## Connecting a MIDI Controller

In order to get information from an external MIDI device into Sonic Pi we first need to connect it to our computer. Typically this will be via a USB connection, although older equipment will have a 5-pin DIN connector for which you’ll need hardware support for your computer (for example, some sound cards have MIDI DIN connectors). Once you’ve connected your device, launch Sonic Pi and take a look at the IO section of the Preferences panel. You should see your device listed there. If not, try hitting the ‘Reset MIDI’ button and see if it appears. If you’re still not seeing anything, the next thing to try is to consult your operating system’s MIDI config to see if it sees your device. Failing all that, feel free to ask questions in our friendly forums: https://in-thread.sonic-pi.net

## Receiving MIDI Events

Once your device is connected, Sonic Pi will automatically receive events. You can see for yourself by manipulating your MIDI device and looking at the cue logger in the bottom right of the application window below the log (if this isn’t visible go to Preferences->Editor->Show & Hide and enable the ‘Show cue log’ tickbox). You’ll see a stream of events such as:

    /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]

Once you can see a stream of messages like this, you’ve successfully connected your MIDI device. Congratulations, let’s see what we can do with it!

## MIDI Time State

These events are broken into two sections. Firstly there’s the name of the event such as `/midi:nanokey2_keyboard:0:1/note_on` and secondly there’s the values of the event such as `[18, 62]`. Interestingly, these are the two things we need to store information in Time State. Sonic Pi automatically inserts incoming MIDI events into Time State. This means you can `get` the latest MIDI value and also `sync` waiting for the next MIDI value using everything we learned in section 10 of this tutorial.

## Besturingscode

Now we’ve connected a MIDI device, seen its events in the cue log and discovered that our knowledge of Time State is all we need to work with the events, we can now start having fun. Let’s build a simple MIDI piano:

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

There’s a few things going on in the code above including some issues. Firstly, we have a simple `live_loop` which will repeat forever running the code between the `do`/`end` block. This was introduced in Section 9.2. Secondly, we’re calling `sync` to wait for the next matching Time State event. We use a string representing the MIDI message we’re looking for (which is the same as was displayed in the cue logger). Notice that this long string is provided to you by Sonic Pi’s autocompletion system, so you don’t have to type it all out by hand. In the log we saw that there were two values for each MIDI note on event, so we assign the result to two separate variables `note` and `velocity`. Finally we trigger the `:piano` synth passing our note.

Now, you try it. Type in the code above, replace the sync key with a string matching your specific MIDI device and hit Run. Hey presto, you have a working piano! However, you’ll probably notice a couple of problems: firstly all the notes are the same volume regardless of how hard you hit the keyboard. This can be easily fixed by using the velocity MIDI value and converting it to an amplitude. Given that MIDI has a range of 0->127, to convert this number to a value between 0->1 we just need to divide it by 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

Update the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let’s get rid of that pesky pause.

## Removing Latency

Before we can remove the pause, we need to know why it’s there. In order to keep all the synths and FX well-timed across a variety of differently capable CPUs, Sonic Pi schedules the audio in advance by 0.5s by default. (Note that this added latency can be configured via the fns `set_sched_ahead_time!` and `use_sched_ahead_time`). This 0.5s latency is being added to our `:piano` synth triggers as it is added to all synths triggered by Sonic Pi. Typically we really want this added latency as it means all synths will be well timed. However, this only makes sense for synths triggered by code using `play` and `sleep`. In this case, we’re actually triggering the `:piano` synth with our external MIDI device and therefore don’t want Sonic Pi to control the timing for us. We can turn off this latency with the command `use_real_time` which disables the latency for the current thread. This means you can use real time mode for live loops that have their timing controlled by `sync`ing with external devices, and keep the default latency for all other live loops. Let’s see:

    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

Update your code to match the code above and hit Run again. Now we have a low latency piano with variable velocity coded in just 5 lines. Wasn’t that easy!

## Waarden ophalen

Finally, as our MIDI events are going straight into the Time State, we can also use the `get` fn to retrieve the last seen value. This doesn’t block the current thread and returns `nil` if there’s no value to be found (which you can override by passing a default value - see the docs for `get`). Remember that you can call `get` in any thread at any time to see the latest matching Time State value. You can even use `time_warp` to jump back in time and call `get` to see past events…

## Now You are in Control

choose

# 11.2 - MIDI Out

In addition to receiving MIDI events we can also send out MIDI events to trigger and control external hardware synths, keyboards and other devices. Sonic Pi provides a full set of fns for sending various MIDI messages such as:

Note on - `midi_note_on` Note off - `midi_note_off` Control change - `midi_cc` Pitch bend - `midi_pitch_bend` Clock ticks - `midi_clock_tick`

There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with `midi_`.

## Connecting to a MIDI Device

In order to send a MIDI message to an external device, we must first have connected it. Check out the subsection ‘Connecting a MIDI Controller’ in section 11.1 for further details. Note that if you’re using USB, connecting to a device which you’re sending to (rather than receiving from) is the same procedure. However, if you’re using the classic DIN connectors, make sure you connect to the MIDI out port of your computer. You should see your MIDI device listed in the preferences pane.

## Sending MIDI events

The many `midi_*` fns work just like `play`, `sample` and `synth` in that they send a message at the current (logical) time. For example, to spread out calls to the `midi_*` fns you need to use `sleep` just like you did with `play`. Let’s take a look:

    midi_note_on :e3, 50

This will send a MIDI note on event to the connected MIDI device with velocity 50. (Note that Sonic Pi will automatically convert notes in the form `:e3` to their corresponding MIDI number such as 52 in this case.)

If your connected MIDI device is a synthesiser, you should be able to hear it playing a note. To disable it use `midi_note_off`:

    midi_note_off :e3

## Selecting a MIDI device

By default, Sonic Pi will send each MIDI message to all connected devices on all MIDI channels. This is to make it easy to work with a single connected device without having to configure anything. However, sometimes a MIDI device will treat MIDI channels in a special way (perhaps each note has a separate channel) and also you may wish to connect more than one MIDI device at the same time. In more complicated setups, you may wish to be more selective about which MIDI device receives which message(s) and on which channel.

We can specify which device to send to using the `port:` opt, using the device name as displayed in the preferences:

    midi_note_on :e3, port: "moog_minitaur"

We can also specify which channel to send to using the `channel:` opt (using a value in the range 1-16):

    midi_note_on :e3, channel: 3

Of course we can also specify both at the same time to send to a specific device on a specific channel:

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

## MIDI Studio

Finally, a really fun thing to do is to connect the audio output of your MIDI synthesiser to one of the audio inputs of your soundcard. You can then control your synth with code using the `midi_*` fns and also manipulate the audio using `live_audio` and FX:

    reverb,

(The fn `midi` is available as a handy shortcut to sending both note on and note off events with a single command. Check out its documentation for further information).

# 12 - OSC

In addition to MIDI, another way to get information in and out of Sonic Pi is via the network using a simple protocol called OSC - Open Sound Control. This will let you send messages to and from external programs (both running on your computer and on external computers) which opens up the potential for control way beyond MIDI which has limitations due to its 1980s design.

For example, you could write a program in another programming language which sends and receives OSC (there are OSC libraries for pretty much every common language) and work directly with Sonic Pi. What you can use this for is only limited by your imagination.

# 12.1 - Receiving OSC

Tijd toestand

## A Basic OSC Listener

Let’s build a basic OSC listener:

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

In this example we described an OSC path `"/osc*/trigger/prophet"` which we’re syncing on. This can be any valid OSC path (all letters and numbers are supported and the `/` is used like in a URL to break up the path to multiple words). The `/osc` prefix is added by Sonic Pi to all incoming OSC messages, so we need to send an OSC message with the path `/trigger/prophet` for our `sync` to stop blocking and the prophet synth to be triggered.

## Sending OSC to Sonic Pi

We can send OSC to Sonic Pi from any programming language that has an OSC library. For example, if we’re sending OSC from Python we might do something like this:

    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])

Or, if we’re sending OSC from Clojure we might do something like this from the REPL:

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

## Receiving from External Machines

For security reasons, by default Sonic Pi does not let remote machines send it OSC messages. However, you can enable support for remote machines in Preferences->IO->Network->Receive Remote OSC Messages. Once you’ve enabled this, you can receive OSC messages from any computer on your network. Typically the sending machine will need to know your IP address (a unique identifier for your computer on your network - kind of like a phone number or an email address). You can discover the IP address of your computer by looking at the IO section of the preferences pane. (If your machine happens to have more than one IP address, hovering the mouse over the listed address will pop up with a list of all known addresses).

Note, some programs such as TouchOSC for iPhone and Android support sending OSC as a standard feature. So, once you’re listening to remote machines and know your IP address you can instantly start sending messages from apps like TouchOSC which enable you to build your own custom touch controls with sliders, buttons, dials etc. This can provide you with an enormous range of input options.

# 12.2 - Sending OSC

In addition to receiving OSC and working with it using Time State, we can also send out OSC messages in time with our music (just like we can send out MIDI messages in time with our music). We just need to know which IP address and port we’re sending to. Let’s give it a try:

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

If you run the code above, you’ll notice that Sonic Pi is sending itself an OSC message! This is because we set the IP address to the current machine and the port to the default OSC in port. This is essentially the same as posting a letter to yourself - the OSC packet is created, leaves Sonic Pi, gets to the network stack of the operating system which then routes the packed back to Sonic Pi and then it’s received as a standard OSC message and is visible in the cue logger as the incoming message `/osc:127.0.0.1:4560/hello/world`. (Notice how Sonic Pi automatically prefixes all incoming OSC messages with `/osc` and then the hostname and port of the sender.)

## Sending OSC to other programs

Of course, sending OSC messages to ourselves may be fun but it’s not that useful. The real benefit starts when we send messages to other programs:

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

In this case we’re assuming there’s another program on the same machine listening to port 123456. If there is, then it will receive a `"/hello/world` OSC message with which it can do what it wants.

If our program is running on another machine, we need to know its IP address which we use instead of `"localhost"`:

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

Now we can send OSC messages to any device reachable to us via our local networks and even the internet!

# 13 - Multichannel Audio

So far, in terms of sound production, we’ve explored triggering synths and recorded sounds via the fns `play`, `synth` and `sample`. These have then generated audio which has played through our stereo speaker system. However, many computers also have the ability to input sound, perhaps through a microphone, in addition to the ability to send sound out to more than two speakers. Often, this capability is made possible through the use of an external sound card - these are available for all platforms. In this section of the tutorial we’ll take a look at how we can take advantage of these external sound cards and effortlessly work with multiple channels of audio in and out of Sonic Pi.

# 13.1 - Sound In

One simple (and perhaps familiar) way of accessing sound inputs is using our friend `synth` by specifying the `:sound_in` synth:

    synth :sound_in

This will operate just like any synth such as `synth :dsaw` with the exception that the audio generated will be read directly from the first input of your system’s sound card. On laptops, this is typically the built-in microphone, but if you have an external sound card, you can plug any audio input to the first input.

## Duurtijd vergroten

One thing you might notice is that just like `synth :dsaw` the `:sound_in` synth only lasts for 1 beat as it has a standard envelope. If you’d like to keep it open for a little longer, change the ADSR envelope settings. For example the following will keep the synth open for 8 beats before closing the connection:

    synth :sound_in, sustain: 8

## FX Toevoegen

Of course, just like any normal synth, you can easily layer on effects with the FX block:

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

If you have plugged in a guitar to your first input, you should be able to hear it with distortion and reverb until the synth terminates as expected.

You are free to use the `:sound_in` synth as many times as you like concurrently (just like you would do with any normal synth). For example, the following will play two `:sound_in` synths at the same time - one through distortion and one through reverb:

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

## Meerdere inputs

You can select which audio input you want to play with the `input:` opt. You can also specify a stereo input (two consecutive inputs) using the `:sound_in_stereo` synth. For example, if you have a sound card with at least three inputs, you can treat the first two as a stereo stream and add distortion and the third as a mono stream and add reverb with the following code:

    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

## Potential Issues

However, although this is a useful technique, there are a couple of limitations to this approach. Firstly, it only works for a specific duration (due to it having an ADSR envelope) and secondly, there’s no way to switch the FX around once the synth has been triggered. Both of these things are typical requests when working with external audio feeds such as microphones, guitars and external synthesisers. We’ll therefore take a look at Sonic Pi’s solution to the problem of manipulating a (potentially) infinite stream of live audio input: `live_audio`.

# 13.2 - Live audio

The `:sound_in` synth as described in the previous section provides a very flexible and familiar method for working with input audio. However, as also discussed it has a few issues when working with a single input of audio as a single instrument (such as a voice or guitar). By far the best approach to working with a single continuous stream of audio is to use `live_audio`.

## A Named Audio Input

`live_audio` shares a couple of core design constraints with `live_loop` (hence the similar name). Firstly it must have a unique name and secondly only one `live_audio` stream with that name may exist at any one time. Let’s take a look:

    live_audio :bla

This code will act in a similar fashion to `synth :sound_in` with some key differences: it runs forever (until you explicitly stop it) and you can move it to new FX contexts dynamically.

## Working with FX

On initial triggering `live_audio` works exactly as you might expect it to work with FX. For example, to start a live audio stream with added reverb simply use a `:reverb` FX block:

    with_fx :reverb do
      live_audio :bla
    end

However, given that `live_audio` runs forever (at least until you stop it) it would be pretty limiting if, like typical synths, the live audio was bound within the `:reverb` FX for its entire existence. Luckily this is not the case and it was designed to be easy to move between different FX. Let’s try it. Run the code above to hear live audio coming directly from the first input of your sound card. Note, if you’re using a laptop, this will typically be out of your built-in microphone, so it’s recommended to use headphones to stop feedback.

Wijzig, terwijl je de live audio van de geluidskaart nog met reverb hoort, nu de code naar het volgende:

    with_fx :echo do
      live_audio :bla
    end

Now, hit Run, and you’ll immediately hear the audio played through the echo FX and no longer through reverb. If you wanted them both, just edit the code again and hit Run:

    with_fx :reverb do
      with_fx :echo do
        live_audio :bla
      end
    end

foo

## Stopping live audio

Unlike standard synths, as `live_audio` has no envelope, it will continue running forever (even if you delete the code, just like a function is still defined in memory if you delete the code in the editor). To stop it, you need to use the `:stop` arg:

    live_audio :bla, :stop

It can easily be restarted by calling it without the `:stop` arg again:

    live_audio :bla

Additionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).

## Stereo input

With respect to audio channels, by default `live_audio` acts similarly to the `:sound_in` synth in that it takes a single mono input stream of audio and converts it to a stereo stream using the specified panning. However, just like `:sound_in_stereo` it’s also possible to tell `live_audio` to read two consecutive audio inputs and treat them as the left and right channels directly. This is achieved via the `:stereo` opt. For example, to treat input 2 as the left signal and input 3 as the right signal, you need to configure the `input:` opt to 2 and enable stereo mode as follows:

    live_audio :bla, stereo: true, input: 2

Note that once you have started a live audio stream in stereo mode, you cannot change it to mono without stopping and starting. Similarly, if you start it in the default mono mode, you can’t switch to stereo without starting and stopping the stream.

# 13.3 - Sound Out

So far in this section we’ve looked at how to get multiple streams of audio into Sonic Pi - either through the use of the `:sound_in` synth or via the powerful `live_audio` system. In addition to working with multiple streams of input audio, Sonic Pi can also output multiple streams of audio. This is achieved via the `:sound_out` FX.

## Output contexts

Let’s quickly recap on how Sonic Pi’s synths and FX output their audio to their current FX context. For example, consider the following:

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

The simplest way to understand what’s happening with the audio stream is to start at the innermost audio context and work our way out. In this case, the innermost context is labelled `A` and is the `:bd_haus` sample being triggered. The audio for this goes directly into its context which is `B` - the `:echo` FX. This then adds echo to the incoming audio and outputs it to its context which is `C` - the `:reverb` FX. This then adds reverb to the incoming audio and outputs to its context which is the top level - the left and right speakers (outputs 1 and 2 in your audio card). The audio flows outwards with a stereo signal all the way through.

## Sound Out FX

The above behaviour is true for all synths (including `live_audio`) and the majority of FX with the exception of `:sound_out`. The `:sound_out` FX does two things. Firstly it outputs its audio to its external context as described above. Secondly it also outputs its audio directly to an output on your sound card. Let’s take a look:

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

In this example, our `:bd_haus` sample outputs its audio to its external context which is the `:sound_out` FX. This in turn outputs its audio to its external context the `:reverb` FX (as expected). However, it also outputs a mono mix to the 3rd output of the system’s soundcard. The audio generated within `:sound_out` therefore has two destinations - the `:reverb` FX and audio card output 3.

## Mono and Stereo out

choose

## Direct Out

As we have also seen, the default behaviour for `:sound_out` and `:sound_out_stereo` is to send the audio both to their external context (as is typical of all FX) and to the specified output on your soundcard. However, occasionally you may wish to only send to the output on your soundcard and not to the external context (and therefore not have any chance of the sound being mixed and sent to the standard output channels 1 and 2). This is possible by using the standard FX opt `amp:` which operates on the audio after the FX has been able to manipulate the audio:

    sample :loop_amen

In het bovenstaande voorbeeld is de `:loop_amen` sample verstuurd naar zijn buitenste context, de `:sound_out` FX. Dit stuurt dan een mono mix naar audiokaart output 3 en vermenigvuldigd de audio vervolgens met 0 wat het feitelijk verstomt. Het is dit verstomde signaal dat wordt uitgestuurd naar de buitenste context van `:sound_out` wat de standaard output is. Daarom ontvangen de default outputkanalen geen audio met deze code en kanaal drie zal een mono mix van de amen drum rust ontvangen.

# 14 - Conclusies

Dit rond Sonic Pi’s handleiding af. Hopelijk heb je terloops iets bijgeleerd. Maak je geen zorgen als het voelt alsof je niet alles begrepen hebt - speel er gewoon mee en heb plezier in wat je doet, zo zal je op je eigen tempo nieuwe leerstof tot je opnemen. Duik gerust terug in een sectie waarover je nog vragen hebt.

Hebt je vragen die nog niet behandeld zijn in de tutorial, ga even naar [Sonic Pi forums] (http://groups.google.com/group/sonic-pi/) en stel je vraag daar. Dan vind je wel iemand die vriendelijk en bereid is om een handje te helpen.

Ten slotte, nodigen ik je ook uit om je wat nader tot de rest van de documentatie in dit help-systeem te wenden. Er zijn een heleboel functies die nog niet behandeld zijn in deze handleiding en die jij nog kan ontdekken.

Dus speel, heb veel plezier, deel jouw code, treed op voor vrienden, toon jouw scherm en vergeet niet:

Er zijn geen fouten, alleen maar kansen

Sam Aaron

# - MagPi artikelen

Bijlage A verzamelt alle de Sonic Pi artikelen geschreven voor het tijdschrift MagPi.

## Duik in Onderwerpen

Deze artikelen zijn niet bedoeld om in een strikte volgorde te worden gelezen en bevatten veel cross-over materiaal uit de tutorial zelf. In plaats van te proberen je alles van Sonic Pi te leren, zijn ze elk gericht op een specifiek aspect van Sonic Pi en dit op een leuke en toegankelijke manier.

## Lees de MagPi

Je kan ze in hun glorieuze professioneel ✓ vorm zien in de gratis PDF-downloads van de MagPi : https://www.raspberrypi.org/magpi/

## Een onderwerp suggereren

Mocht het zijn dart er een onderwerp ontbreekt dat jou interesseert - waarom zou je daar dan geen suggestie over kunnen maken? De makkelijkste manier om dit te doen is jouw suggestie tweeten naar @Sonic_Pi. Jouw suggestie kan wel eens het onderwerp van het volgende artikel zijn!

# - Vijf Top Tips

## 1. Er bestaan geen fouten

De belangrijkste les om leren in Sonic Pi is dat er geen echte fouten bestaan. De beste manier van leren is om gewoon te proberen en te proberen en te proberen. Probeer verschillende dingen uit, stop ermee je zorgen te maken of je code nu goed klinkt of niet en begin te experimenteren met zoveel mogelijk verschillende synths, noten, FX als mogelijk is. Je zal ontdekken dat je een heleboel dingen maakt die je aan het lachen brengen omdat het gewoon verschrikkelijk klinkt en soms zullen er echte juweeltjes tussen zitten, die echt geweldig klinken. Laat gewoon de dingen vallen die u niet graag doet en hou van wat je doet. Hoe meer `fouten` je jezelf toelaat te maken hoe sneller je zaken zal leren en jouw persoonlijke geluids codering zal ontdekken.

## 2. FX gebruiken

Laat ons aan nemen dat je de basis om klanken te maken in Sonic Pi met `sample`, `play`. Wat nu? Wist je dat Sonic Pi over de 27 studio ondersteunt om de sound van je code te veranderen. Effecten zijn zoals beeldfilters in tekenprogramma’s maar in plaats van zaken te vervagen of zwart-wit te maken, kan je zaken aan jouw geluid toevoegen zoals reverb, distortion, en echo. Het concept isq zoals je een geluidskabel vanuit je gitaar in de effectenpedaal van jou keuze te steken en vervolgens de versterker in. Gelukkig maakt Sonic Pi je het heel makkelijk om FX te gebruiken en dit zonder kabels! Het enige wat je moet doen is het fragment in jouw code selecteren waar je FX wil op gebruiken en deze met de FX code omhullen. Laten we naar een voorbeeld kijken. Stel dat je deze code hebt:

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

Als je een FX aan de `:loop_garzul` sample wil toevoegen, moet je deze gewoon in een `with_fx` blok steken zoals hier:

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

Als je nu ook een FX aan de bass drum wil voegen, omhul deze dan ook met een `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

Denk eraan , je kan elke code omhullen met `with_fx` en elke klank hierin gecreëerd zal door deze FX passeren.

## 3. Het parametreren van jouw synths

Om je eigen geluid te gaan ontwikkelen, zal je snel willen leren, hoe je synths en Fx kan veranderen en controllen. Zo wil je bijvoorbeeld de lengte van een noot veranderen, of wil je wat meer reverb toevoegen, of de tijdsinstellingen van een echo aanpassen. Gelukkig geeft Sonic Pi de mogelijkheid om dit op een hoog niveau te gaan doen met behulp van optionele parameters of in het kort: opts. Laten we dit even bekijken. Kopieer de volgende code in een werkveld en klik afspelen:

    sample :guit_em9

Ooh, een mooie gitaarklank! Nu gaan we hiermee spelen. Wat dacht je van zijn koers te veranderen?

    sample :guit_em9, rate: 0.5

Hé, wat is dat stukje `rate: 0.5`, dat daar op het einde staat? Dat is een opt! Alle synths en FX van Sonic Pi ondersteunen deze en er zijn er tal van beschikbaar om mee te spelen. Probeer deze eens:

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

Probeer nu de feedback te verhogen naar 1 om maffe klanken te horen. Lees de documentatie voor details over de beschikbare opts.

## 5. Live Code

De beste manier om zaken snel te ontdekken in Sonic Pi is experimenteren en live te coderen. Dit laat jou toe om stukjes code op te starten en deze voortduren te veranderen en te controllen terwijl je speelt. Bijvoorbeeld, als je niet weet wat de cutoff parameter doet met een sample, speel er gewoon mee, probeer het. Kopieer deze code in één van je werkvelden:

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

Klik nu op afspelen en hoor hierbij een licht gedempte drum break. Verander de cutoff waarde nu naar `80` en klik opnieuw op afspelen. Hoor je het verschil? Probeer `90`, `100`, `110`…

Eens je het gewoon bent `live_loop`s te gebruiken zal je nooit meer zonder deze kunnen. Wanneer ik een live coding doe reken ik hier zwaar op, zoals een drummer zijn drumsticks nodig heeft. Voor meer informatie over live coding, kijk naar Sectie 9 van de ingebouwde handleiding.

## 5. Surfen op random golven

Tot slot nog deze, ik hou ervan om een beetje vals te spelen door Sonic Pi in mijn plaats te laten componeren. Een goede manier om dit te verwezenlijken is gebruik te maken van het randomiseren. Misschien lijkt dit een beetje ingewikkeld maar dat is het helemaal niet. Laat ons hiernaar naar kijken. Kopieer deze in een lege buffer:

    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

Wanneer je deze afspeelt zal je een constante stroom van random noten horen spelen in de toonladder `:e2 :minor_pentatonisch` gespeeld met de synth `:dsaw`.” Maar wacht! Dat is geen melodie” hoor ik jou roepen! Wel, dit is ook het eerste deel van onze tovertruc. Elke keer we rond gaan in de `live_loop`, kunnen we Sonic Pi vertellen om de random toeloop naar een gegeven punt te resetten. Dit is een beetje zoals in de tijd teruggaan met de dokter in de TARDIS naar een bepaald punt in tijd en ruimte. We proberen de lijn `use_random_seed 1` toe te voegen aan de `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

Nu, elke keer de `live_loop` rond gaat , wordt de random stream gereset. Dit betekend dat iedere keer dezelfde 16 noten gekozen worden. En presto! Instant melodie. Nu komt het spannende deel. Verander de seed waarde van `1` naar een ander getal. Neem `4923`. Wauw! Een andere melodie! Dus door gewoon één cijfer te veranderen (de random seed), je kan je zoveel melodische combinaties gaan verkennen als je je kan voorstellen ! Nu, dat is de magie van code.

# - Live Coderen

De laserstralen sneden door de slierten rook, terwijl de subwoofer de bassen diep in de lichamen van de menigte pompten. De sfeer was rijp met een onstuimige mix van synths en dansbewegingen. Maar tegelijkertijd klopte er iets niet in deze discotheek. In felle kleuren boven de DJ booth was een futuristische tekst geprojecteerd die knipperde en heen en weer bewoog. Het waren geen hype visuals, maar een projectie van Sonic Pi op een Raspberry Pi. De aanwezige in de DJ booth draaide geen plaatjes, hij was code aan het schrijven, aanpassen en redigeren. Live. Dit is Live Coding.

Dit klinkt misschien als een vergezocht verhaal van een futuristische nachtclub maar codering van muziek zoals deze is een groeiende trend en wordt vaak omschreven als Live codering (http://toplap.org). Een van de recente benadering van muziek spelen is de Algorave (http://algorave.com) - evenementen waar artiesten zoals ik code schrijven voor mensen om op muziek te dansen . Echter, je hoeft niet naar een nachtclub te trekken voor een Live Code - met Sonic Pi v2.6 + kan je het overal waar je je Raspberry Pi kunt meenemen met een paar hoofdtelefoons of luidsprekers. Voor je het einde van dit artikel kan lezen, zal je je eigen beats programmeren en hen live wijzigen. Waar je enkel beperkt wordt door uw verbeelding.

## Live Loop

De hoofdzaak bij het live coderen ligt bij het beheersen van de `live_loop`. Hier kijken we naar zo ééntje:

    live_loop :beats do
      sample :bd_haus
      sleep 0.5
    end

Er zitten 4 basisingrediënten in een `live_loop`. De eerst is de naam. Onze `live_loop`heet `:beats`. Je kan jouw `live_loop`benoemen zoals jij dat wil. Doe dwaas. Wees creatief. Ikzelf gebruik benamingen die een uitleg geven over welke klank zij naar het publiek brengen. Het volgende ingrediënt is het `do` woord die markeert waar de `live_loop` start. het derde is het `end`woord dat het einde van onze`live_loop markeert, en tenslotte heb je de inhoud van de` live_loop`waarin beschreven wordt wat de loop gat herhalen- dat is het stukje tussen` do`en` end`. In dit geval gaan we de bass drum sample met een halve tel rusttijd spelen . Dit produceert een aangenaam regelmatige bass beat. Ga je gang, kopieer deze in een lege buffer en klik op afspelen. Boem, boem, boem!.

## Ter plekke herdefiniëren

OK, dus wat is er nu zo speciaal aan de ‘live_loop’? Tot nu toe lijkt het gewoon een veredelde ‘loop’! Nou, de schoonheid van ‘ de live_loop is dat u hen ter plekke kan herdefiniëren. Dit betekent dat terwijl deze nog steeds speelt, kan je veranderen wat ze doen. Dit is het geheim van het live coderen met Sonic Pi. Laten we eens spelen:

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

Klik nu op de afspeelknop of gebruik `alt-r`. Je luistert nu naar de prachtige klank van een koor. Verander de koers, terwijl de code speelt van `0.4` naar `0.38`. Klik terug op afspelen. Woeha! Hoorde je het koor van toon veranderen? Verander deze terug naar `0.4` om terug te keren hoe het was. Verlaag deze nu naar `0.2`, verlaag naar `0.19` en terug naar omhoog naar `0.4`. Hierbij zie je dat het improviseren op één parameter, jou de controle over jouw muziek geeft? Speel zelf met de waarden die je kiest. Probeer negatieve getallen, hele kleine en hele grote getallen. Veel plezier!

## Slapen is belangrijk

Een van de belangrijkste lessen over `live_loop`s is dat ze rust nodig hebben. Beschouw deze volgende ‘live_loop’:

    live_loop :infinite_impossibilities do
      sample :ambi_choir
    end

Wanneer je deze code probeert te laten lopen, zie je onmiddellijk dat Sonic Pi klaagt dat de `live_loop` geen `sleep` toebedeeld heeft gekregen. Dit is het veiligheidssysteem dat in werking treedt! Nemen even de tijd om erover na te denken wat je aan de computer vraagt met deze code. Juist, het vraagt de computer een oneindig aantal koorsamples te af te spelen op nul tijd. Zonder het veiligheidssysteem zou de arme computer crashen tijdens dit proces. Dus onthou dat jouw `live_loop` een `sleep` moet bevatten.

## Geluiden combineren

In muziek gebeuren veel dingen tezelfdertijd. Drums spelen op het zelfde moment als de bass en op het zelfde moment als zang en gitaar… In Computing noemen we dit samenwerking en Sonic Pi biedt ons een ongelofelijk eenvoudige manier om zaken samen te laten spelen. Gewoon gebruik maken van verschillende `live_loop`s!

    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

Hier hebben we twee `live_loops` de ene speelt snel en maakt beats, de andere speelt snel en maakt maffe bas geluiden.

Eén van de interessante zaken aan het gebruik van meerdere `live_loop`s is dat deze hun eigen onafhankelijke tijd kunnen hebben. Dit betekend dat je makkelijk interessante poly-ritmische structuren kan maken en zelfs kan spelen met fase-verschuivingen in de stijl van Steve Reich. Check deze:

    # Steve Reich's Piano Phase
    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

## Waardoor het allemaal samen valt

In elk van deze tutorials eindigen we met een muzikaal voorbeeld waarin alle ideeën die werden voorgesteld samen worden gebracht. Bekijk de code en probeer je voor te stellen wat deze zou gaan doen. Plak deze dan in een lege buffer in Sonic Pi en druk op afspelen, en luister nu hoe dit klinkt. Verander tenslotte één van de getallen en schakel commentaarlijnen in om lijnen in en uit te schakelen. Bekijk of je dit ook niet kan gaan gebruiken in een live optreden, en boven alles,beleef hier plezier aan! Tot volgende keer…

    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

# - Gecodeerd Beats

Een van de meest revolutionaire en vernieuwende ontwikkeling op technisch gebied was de uitvinding van de sampler.Dit waren kisten die jou toelieten eender welke klank op te nemen, te manipuleren en terug af te spelen, op vele interessante manieren. Bijvoorbeeld kon je van een oude plaat een drumsolo (of een break) nemen, deze opnemen op jouw sampler en deze dan op repeat aan halve snelheid afspelen om de basis te leggen van je nieuwe beats. Dit is hoe old school hip-hop werd geboren en vandaag is het haast onmogelijk om Elektronische muziek te vinden die geen gebruik maken van één of andere sample. Het gebruik van samples is een geweldige manier om makkelijk nieuwe en interessante elementen aan jouw live code toe te voegen.

Dus waar kan je zo’n sampler krijgen? Wel je hebt er al één- het is jouw Raspberry Pi! The ingebouwde codeer app Sonic Pi heeft een uiterst krachtige sampler ingebouwd in zijn core. Laten we ermee gaan spelen!

## De Amen Break

Een van de meest klassiek en herkenbare drum break samples is de Amen Break. Het werd voor het eerst uitgevoerd in 1969 in het nummer “Amen Brother” door de Winstons als een gedeelte in een drumbreak. Het was echter wanneer het werd ontdekt door de vroege hip-hop muzikanten in de jaren 80 en werd gebruikt in samplers dat de start werd gegeven deze sample in vele stijlen te gaan gebruiken zoals drum& bass, breakbeat, hardcore techno en breakcore.

Ik ben er zeker van dat je blij bent dat deze standaard ingebouwd zit in Sonic Pi. Ruim even een buffer leeg en gooi er de volgende code in:

    sample :loop_amen

Klik op Afspelen en Boem. Je luistert nu naar één van de meest invloedrijke drumbreaks in de geschiedenis van dance music. Als one-shot was deze niet populair natuurlijk wel als loop.

## Beat Stretching

Laat ons de Amen Break loopen in onze goede vriend `live_loop`, geïntroduceerd in deze tutorial van vorige maand:

    live_loop :amen_break do
      sample :loop_amen
      sleep 2
    end

OK, deze loopt nu, maar er is wel een vervelende pauze elke keer dat hij zijn cyclus heeft volbracht. Dat komt omdat we het een `sleep`-tijd van`2`tellen hebben gegeven en met de standaard 60 BPM duurt de `:loop_amen` sample `1.753` tellen. Hierdoor hebben we een stilte van `2 - 1.753 = 0.247` tellen. Ook al is deze kort, het is wel merkbaar.

Om dit probleem op te lossen kunnen we de `beat_stretch`opt gebruiken om Sonic Pi op te dragen deze sample uit te rekken (of te doen inkrimpen) om met het opgegeven aantal tellen overeen te laten komen.

De `sample`en `synth` fns van Sonic Pi geven jou veel controle over de optionele parameters zoals `amp:`, `cutoff:`en `release:` . Maar de term optionele parameter is wel een mond vol, dus noemen we deze opts om de zaken eenvoudig te houden.

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

Nu zijn we aan het dansen! Maar misschien willen we het wat sneller of wat trager om de juiste stemming te pakken te krijgen.

## Spelen met Tijd

Ok, en als we de stijl willen aanpassen naar old school hip hop of breakcore? Een eenvoudige manier om dit te gaan doen is te spelen met tijd -of in andere woorden: aan het tempo klooien. Dit is makkelijk te doen in Sonic Pi, gooi gewoon `use_bpm` in je live loop:

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

Terwijl je over deze trage beats heen rapt merk je dat we nog steeds voor 2 `sleep`hebben en dat onze BPM 30 is, maar alles is wel in maat. De `beat_stretch`opt werkt met de huidige BPM om ervoor te zorgen dat alles werkt.

Nu komt het leuke! Terwijl de loop nog altijd speelt, verander de`30`in de `use_bpm 30`regel naar `50`. Woeha, Alles gaat nu sneller, en in maat gehouden! Probeer sneller te gaan - omhoog naar 80, naar 120, doe nu eens goed zot en gebruik 200!

## Filteren

Nu we samples kunnen live lopen, laat ons eens kijken naar de leukste opts die bij de `sample`synth geleverd zijn. Eerst komt `cutoff`aan beurt, welke de cutoff op de filter van de sampler regelt. Standaard is deze uitgeschakeld, maar je kan deze makkelijk aanzetten:

    live_loop :amen_break do
      use_bpm 50
      sample :loop_amen, beat_stretch: 2, cutoff: 70
      sleep 2
    end

Ga je gang en verander de `cutoff:` opt. Verhoog deze bijvoorbeeld naar 100, klik op Afspelen en wacht een cyclus van de loop af om de verandering van het geluid waar te nemen. Merk op dat lage waarden zoals 50 zacht klinken en laag en hoger waarden zoals 100 en 120 voller klinken en rasperig. Dit is omdat de `cutoff:`opt de hoge geluidsfrequentie afsnijdt zoals een grasmaaier de grasuiteinden afknipt. De `cutoff:` opt is zoals de lengte instelling, en bepaald hoeveel gras overblijft.

## Slicing (Snijden)

Nog een fantastisch hulpmiddel om mee aan de slag te gaan is de slicer FX. Deze zal het geluid uiteen hakken (snijden). Omhul de `sample`regel met de FX code als volgt:

    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

Merk op hoe de klank op en neer stuitert, elke keer meer. (Je kan de originele klank, zonder FX, beluisteren door de `mix` opt naar `0`te veranderen) Speel nu met de `phase:` opt. Dit is de snelheid (in slagen) van het slicing effect. Een kleinere waarde zoals `0.125` zal sneller hakken en grotere waarden zoals `0.5` zullen trager snijden. Merk hierbij op dat het opeenvolgend halveren of verdubbelen van de `phase:`opt waarde altijd goed schijnt te klinken. Verander tenslotte de `wave:` opt naar 0,1 of 2 en hoor hoe dit de klank veranderd. Dit zijn de verschillende golfvormen. 0 is een zaagtand-golf, (harde aanslag, fade-out) 1 is een blokgolf (harde aanslag, geen fade-out) en 2 is een driehoeksgolf (fade-in, fade out).

## Waardoor het allemaal samen valt

Laten we tenslotte terug in de tijd gaan en de vroege drum&bass scene van Bristol bezoeken, met het voorbeeld van de maand. Maak je geen zorgen als je echt niet weet over wat dit gaat, type deze even, klik op Afspelen, begin te live code-en, door de getallen van de opt te veranderen en kijk wat je dit oplevert. Deel alsjeblieft wat je hebt gemaakt! Tot Volgende keer…

    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

# - Synth Riffs

Of het nu spokende onstuimige, grommende oscillatoren zijn of de ontstemde aanslag van zaagtand-golven die door de mix klieven, de lead synth zal altijd een essentiële rol spelen in een elektronisch nummer. In de editie van vorige maand in deze serie zelf-studies zagen we hoe je je beats code maakt. In deze tutorial gaan we zien hoe we de code doen van drie hoofd componenten van een synth riff: het timbre, de melodie en het ritme.

Ok, zet je Raspberry Pi op, maak Sonic Pi v2.6+ open en maak wat lawaai!

## Timbrale mogelijkheden

Een essentieel onderdeel van zowat elke synth riff ligt in het veranderen en bespelen van het timbre. We kunnen het timbre in Sonic Pi op twee verschillende manieren controllen: veranderen van synth voor een drastische verandering en de verschillende synth opts gebruiken voor een meer subtiele aanpak. We kunnen ook FX gebruiken, maar dat is voor een andere tutorial…

We creëren een eenvoudige loop waar we de huidige synth voortdurend gaan veranderen:

    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

Kijk even naar de code. We tikken gewoon door een ring van synth namen (deze zal de lijst helemaal doorlopen en aan het einde opnieuw beginnen). We geven deze synth naam door aan de `use_synth` fn (functie) die de `live_loop`’s huidige synth verandert. We spelen ook de noot `:e2` (E van het tweede octaaf), met een release tijd van 0.5 tel (een halve seconde aan de standaard BPM van 60) en met een `cutoff:`opt naar 100 gezet.

Hoor hoe de verschillende synths zeer grote verschillen vertonen hoewel ze dezelfde noot spelen. Experimenteer nu en speel hiermee. Verander de release tijden naar grotere en kleinere waarden. Verander bijvoorbeeld de `attack:` en `release:` opts om te zien hoe verschillende cutoff waarden een invloed hebben op het timbre (waarden tussen 60 en 130 zijn goed) Kijk hoeveel verschillende klanken je kan creëren door simpelweg enkele waarden aan te passen. Eens je dit onder de knie hebt, ga dan naar de synths tab in het hulpsysteem voor de lijst van alle synths en de voor iedere individuele synth beschikbare opts, om te zien hoeveel kracht je hiermee onder je codende vingers hebt.

## Timbre

Timbre of klankkleur is enkel een moeilijk woord om de klank van een geluid te beschrijven. Als je dezelfde noot speelt met verschillende instrumenten zoals viool, gitaar of piano zal de toonhoogte altijd dezelfde zijn, maar de klankeigenschap zal anders zijn. Deze eigenschap die het mogelijk maakt om het verschil tussen een piano en een gitaar waar te nemen is het timbre.

## Melodische Compositie

Een ander belangrijk aspect dat onze lead synth is de keuze van de noten die wij willen spelen. Als je al een goed idee hebt, dan kan je gewoon een ring met jouw noten :

    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

Hier hebben de melodie gedefinieerd met een ring die beide noten `:e3` en de rust ´:r bevat. We gebruiken dan `.tick` om door elke noot te lopen, om zo een herhalende riff te krijgen.

## Auto Melodie

Het is niet altijd gemakkelijk om met een mooie riff voor de dag te komen. In plaats daarvan is het vaak makkelijker Sonic Pi te vragen naar een selectie van willekeurig riff’s en waaruit je dan kan kiezen ,welke jou het beste bevalt. Om dit te kunnen gaan doen, moeten we drie zaken combineren: ringen, randomiseren en random seeds. Laten we eens kijken naar een voorbeeld:

    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

Een aantal zaken gebeuren hier, laat ons deze even afzonderlijk bekijken. Eerst specifiëren we dat we random seed 3 gebruiken. Wat betekent dit? Wel het nuttige hieraan is dat wanneer we de seed instellen, we ook kunnen voorspellen wat de volgende willekeurige waarde zal zijn, namelijk dezelfde als de laatste keer dat we de seed op 3 hadden ingesteld! Goed om weten is ook, dat een shuffle van kring van noten, op dezelfde manier werkt. In het bovenstaande voorbeeld vragen we eigenlijk de ‘derde shuffle’ in de standaard lijst van shuffles op, die steeds ook dezelfde is, gezien we de random seed instellen op de zelfde waarde vlak voor de shuffle. Ten slotte tikken we met `.tick` door de ge-shuffle-de noten, om onze riff af te spelen.

En nu wordt het leuk. Als we de waarde van de random seed veranderen naar bvb. 3000, krijgen we een geheel nieuwe shuffle van noten. Het is nu wel extreem makkelijk om nieuwe melodieën te gaan ontdekken. Kies simpelweg de lijst van de noten die je wil verschuiven met shuffle ( toonladders zijn hierbij een mooi uitgangspunt) en kies dan de seed waarmee je de shuffle wil doen. Als de melodie jou niet bevalt, verander dan één van deze twee dingen en probeer opnieuw. Herhaal dit tot je iets tegenkomt dat je wel graag hoort!

## Pseudo randomiseren

Sonic Pi’s randomiseren is niet echt willekeurig (random) en is daarom pseudo random. Stel je voor je een dobbelsteen 100 keer zou opgooien en het resultaat van elke opgooi op een stuk papier zou moeten noteren. Sonic Pi heeft het equivalent van deze resultatenlijst, die zij dan gebruikt, wanneer je om een willekeurige waarde vraagt. In plaats van werkelijke dobbelstenen, pakt het gewoon de volgende waarde uit de lijst. Het instellen van random seed, is gewoon het springen naar een bepaald punt in die lijst.

## Jouw Ritme Vinden

Nog een belangrijk element van onze riff is het ritme, wanneer een noot spelen en wanneer niet. Zoals we hierboven al zagen, kunnen we `:r` in onze ringen gebruiken, om een rusttijd in te zetten. Nog een andere, krachtige, manier is het gebruik maken van spreads, wat we in een toekomstige leeroefening gaan bekijken. Vandaag zullen we gebruik maken van randomiseren, om ons te helpen, ons ritme te vinden. In plaats van elke noot te spelen kunnen we een voorwaardelijke gebruiken, om een noot te spelen met een gegeven waarschijnlijkheid. Laat ons eens een kijkje nemen:

    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

Een heel nuttige functie om te onthouden is `one_in`, welke ons een `true` of `false` waarde geeft met een bepaalde waarschijnlijkheid. Hier gebruiken we een waarde van 2, die gemiddeld één keer per twee oproepen naar `one_in`, `true zal weergeven. Door hogere waarden te gebruiken kunnen we` false` meer weergegeven laten worden, waardoor we meer ruimte in de riff kunnen creëren.

Merk op dat we hier een iteratie met `16.times` hebben toegevoegd. Dit doen we alleen omdat we onze random seed waarde om de 16 noten willen resetten, zodat ons ritme elke 16 keer herhaalt. Dit beïnvloed de shuffle niet, vermits deze direct achter de seed staat. We kunnen de grootte van de iteratie wijzigen om, om de lengte van de riff te veranderen. Probeer 16 naar 8 te veranderen of zelfs aar 4 of 3 en zie hoe dit de lengte van de riff beïnvloed.

## Waardoor het allemaal samen valt

Ok, laat ons nu alles wat we geleerd hebben in een laatste voorbeeld combineren. Tot volgende keer!

    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

Als we naar de geschiedenis van elektronische dansmuziek kijken, kunnen we niet naast de enorme impact van de kleine Roland TB-303 synthesizer kijken Het is het geheime recept van het originele acid bass geluid.

Interessant om weten is ook dat Roland de TB-303 niet voor dancemuziek heeft ontwikkeld. Het werd oorspronkelijk gemaakt als ondersteuning voor gitaristen bij het oefenen. Ze stelden zich voor dat men bas-lijnen ging programmeren om dan samen met de gitaar te gaan jammen. Helaas waren er een aantal problemen: ze waren een beetje onhandig om te programmeren, niet bijzonder goed als vervanging van een bas-gitaar geluid en vrij duur om te kopen. Het sloeg niet aan en om verlies te vermijden werd er beslist met de productie te stoppen na 10.000 exemplaren. Al snel vonden ze hun weg naar de etalage van de tweedehands winkels. De afgedankte TB-303’s lagen nu te wachten om ontdekt te worden door een nieuwe generatie die hen op een manier zou gaan gebruiken die Roland niet voor ogen had. Acid house was geboren.

Vermits het in handen krijgen van een originele TB-303 niet eenvoudig is, zal u blij zijn te horen dat je jouw Raspberry Pi makkelijk kan omtoveren tot een TB-303 met de kracht van Sonic Pi. Ziehier, start Sonic Pi, gooi de code in een lege buffer, en druk op afspelen:

    use_synth :tb303
    play :e1

Acid Bass in een oogwenk! We gaan hier mee spelen…

## Smak die Bas

Laten we eerst een arpeggiator maken om de zaken leuk te houden. In de laatste tutorial hebben gezien hoe riffs gewoonweg een ring van noten kunnen zijn waar we, de ene na de andere doorheen “tikken”, en zich gaan herhalen eens ze aan het einde van de cyclus zijn gekomen. Laten we een live loop maken die dat doet:

    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

Laten we naar elke regel een kijkje nemen.

Op de eerste regel zetten we de standaard synth als ‘tb303’ met de ‘use_synth’ fn. Op regel twee creëren we een live loop genaamd ‘: squelch’ die in een lus loopt. In regel drie creëren we onze riff, een ring van noten (E in de octaven 1, 2 en 3) die we simpelweg met `.tick` gaan “tikken”. We definiëren `n` om de huidige noot in de riff te vertegenwoordigen. Het gelijkheidsteken betekent dat de waarde rechts, aan de naam links wordt verwezen. Deze zal in elke loop cyclus anders zijn. In de eerste loop zal `n` naar `:e1` gezet worden. In de tweede loop cyclus zal dit `:e3`zijn gevolgd door `:e3`, en dan terug naar `:e1`, om zo voor altijd zijn cyclus te herhalen. Regel vier is waar we onze `:tb303` synth activeren. En we passeren aan deze een aantal interessante opts: `release:`, `cutoff:`, `res:` and `wave:` dewelke we hieronder gaan bespreken. Regel vijf is onze ´sleep´’ - we vragen de live loop elke ‘ 0,125` of 8 keer per seconde op de standaard BPM van 60 te gaan loop-en. Regel 6 is het einde van de live loop. Deze vertelt aan Sonic Pi waar het einde van de live loop is.

Terwijl je nog steeds uitzoekt wat er gaande is, typt u de bovenstaande code in en druk op de knop afspelen. Je zou nu de `:tb303` in actie moeten horen schieten. Nu, hier begint de pret: laten we beginnen live-coderen.

Terwijl de loop afspeelt, verander je de `cutoff:` opt naar `110`. Klik nu opnieuw op de Afspeel knop. Je zou het geluid nu harder en rauwer moeten horen afspelen. Verander deze nu op `120` en klik op Afspelen. Nu `130`en hoor het geluid intenser en meer snijdend worden. Ga tenslotte terug naar `80` wanneer het jou ter druk wordt. Herhaal dit zoveel je wil. Geen nood, ik zal hier nog wel zijn :) …

Een andere opt die de moeite waard is, is `res`. Deze bedient het niveau van de resonantie van de filter. Een hoge resonantie is een typisch kenmerk van de Acid Bass geluiden. Ons huidig niveau is `0.8`. Draai deze omhoog naar `0.85`, dan `0.9` en tenslotte naar `0.95`. Je zult hierdoor merken dat met een cutoff van `110`, de verschillen makkelijker hoorbaar zullen zijn. Doe tenslotte maar eens goed gek, door ´0999´ te gebruiken, voor een krankzinnig geluid. Aan zo een hoge `res` zal de cutoff filter zo hard resoneren dat deze zelf gaat oscilleren, en zo zelf een geluidsbron wordt!

Tenslotte veranderen we de golfvorm met de ´wave:´ opt naar `1`. Dit is de keuzeschakelaar van de oscillator. Standaard is deze `0`, deze is de zaagtand geluidsgolf (sawtooth wave).`1`is de pulsgolf (pulse wave) en `2`is de triangelgolf (triangle wave).

Je kan natuurlijk ook andere riffs gebruiken door de noten te veranderen in de ringen of zelfs noten te plukken uit toonladders en akkoorden. Veel plezier met je eerste Acid Bass synth.

## De TB-303 deconstrueren

Het ontwerp van de oorspronkelijke TB-303 is eigenlijk vrij eenvoudig. Zoals je in het volgende diagram ziet, zijn er maar 4 belangrijke kerndelen.

Ten eerste is de wave oscillator - de grondstoffen van het geluid. In dit geval hebben we een blokgolf. Vervolgens is er de amplitude envelop van de oscillator, die de amplitude van de blokgolf door de tijd bedient. Deze zijn toegankelijk in Sonic Pi door de `attack:`, `decay:`, `sustain:` and `release:` opts vergezeld door het niveau hiervan. Lees voor meer informatie de sectie 2.4 ‘Duurtijd met enveloppen’ in de ingebouwde handleiding. Vervolgens sturen we deze blokgolf met zijn envelop door een resonant low-pass filter. Dit dit snijdt in de hogere frequenties en heeft dat mooi resonantie-effect. Hier begint de pret. De grenswaarde van deze filter wordt ook gecontroleerd door eigen envelop! Dit betekent dat we een geweldige controle hebben over de klankkleur van het geluid door te spelen met beide van deze enveloppen. Laten we dit eens bekijken:

    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

Voor elke standaard envelop opt, is er een ‘cutoff_’ gelijkwaardige opt-in de ‘: tb303’ synth. Dus, om het tijdsverloop van de attack van de cutoff kunnen we de ‘ cutoff_attack:’ opt gebruiken . Kopieer de code hierboven in een lege buffer en druk op Afspelen. Je hoort een gek geluidje in en uit kwelen. Begin hiermee te spelen te spelen. Probeer de ‘ cutoff_attack:’ tijd naar te `1` te brengen en vervolgens naar `0.5`. Probeer daarna `8`.

Merk ook op dat ik alles door een `:reverb` FX heb gestuurd voor een extra sfeer, probeer zeker een ander FX uit en zie of dit werkt!

## Waardoor het allemaal samen valt

Tenslotte nog een stuk dat ik gecomponeerd heb met de ideeën van deze tutorial. kopieer deze in een lege buffer, luister er even naar en verander de parameters in een live coding. Kijk welke krankzinnige geluiden je ermee kan maken! Tot volgende keer…

    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

# - Muzikale Minecraft

Hallo en welkom terug! In de vorige tutorials heb we gericht puur op de mogelijkheden rond muziek in Sonic Pi - ( Je Raspberry Pi in een muziekinstrument veranderen). Tot nu toe hebben we geleerd geleerd hoe te:

Live Code - ter plekke wijzigen van het geluid, Geweldige Beats coderen, Krachtige synth leads, genereren De bekende TB-303 recreëren.

Er is zoveel meer om te laten zien (die we in toekomstige versies zullen onderzoeken). Echter, deze maand, gaan we eens kijken wat je met Sonic Pi kunt doen en je waarschijnlijk niet weet: controle hebben over Minecraft.

## Hello Minecraft World

We gaan aan de slag. Start je Raspberry Pi, alsook Minecraft Pi en creëer een nieuwe wereld. Start Sonic Pi nu op en schik de vensters van deze programma’s, zodat je zowel Sonic Pi als Minecraft Pi gelijkertijd kan zien.

In een nieuwe buffer typ je dan het volgende:

    mc_message "Hello Minecraft from Sonic Pi!"

Klik nu op afspelen. En Bam! Jouw bericht verschijnt nu in Minecraft! Was dat niet makkelijk? Speel hier nu mee met je eigen berichten. Veel plezier ermee!

## Sonic Teleporter

Nu gaan we op verkenning. De standaard optie is werken met de muis en het klavier en beginnen rondlopen. Dat werkt wel, maar het is behoorlijk traag en saai. Het zou veel beter zijn moesten we een soort teleportatie machine hebben. Wel, dankzij Sonic Pi, hebben we dat ook. Probeer deze:

    mc_teleport 80, 40, 100

Jeetje! Dat duurde even. Als je niet in de vliegende-modus zou zijn, was je die afstand helemaal naar beneden gevallen. Als je space twee keer aanslaat om in vliegmodus te gaan en opnieuw te teleporteren, blijf je zweven op de plaats waar je naartoe zapte.

Nu, wat betekenen deze cijfers ? We hebben drie getallen die de coördinaten beschrijven, waar in de wereld we willen naartoe gaan . We geven elk nummer een naam - x-, y- en z:

x - hoe ver links en rechts (80 in ons voorbeeld) y - hoe hoog we willen zijn (40 in ons voorbeeld) z - hoe ver voorwaarts of achterwaarts (100 in ons voorbeeld)

Door verschillende waarden te kiezen voor x, y en z kunnen we “overal” in de onze wereld teleporteren. Probeer maar! Kies hierbij verschillende getallen en kijk waar je terechtkomt. Wanneer je scherm zwart wordt betekent dit dat je jezelf onder de grond of in een berg hebt geteleporteerd. Kies dan gewoon een een hoger getal voor y om terug op land te komen. Ga door tot je op een leuke plek terecht gekomen bent…

Met behulp van de tot nu toe aangereikte ideeën, gaan we nu een Sonic Teleporter die een leuk teleportatie geluid maakt als door de Minecraft wereld zoeven:

    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!"

## Magische blokken

Nu je een leuke plek gevonden hebt, gaan we beginnen bouwen. Je kan nu zoals je gewoonlijk doet verwoed gaan klikken om blokken onder de cursor te plaatsen. Of je kan de magie van Sonic Pi gebruiken. Probeer dit:

    x, y, z = mc_location
    mc_set_block :melon, x, y + 5, z

Kijk omhoog! Er hangt een meloen in de lucht! Neem even de tijd om naar de code te kijken. Wat hebben we hier gedaan? Op lijn één namen we de huidige locatie van Steve als de variabelen x, y en z. Deze komen overeen met onze coördinaten hierboven beschreven. Wij gebruik deze coördinaten in de fn ‘mc_set_block’, die de blok van uw keuze zal plaatsen op de opgegeven coördinaten.Als we deze nu omhoog willen plaatsen, moeten we de waarde van y verhogen,dat is ook de reden waarom we er 5 aan hebben toegevoegd. Laten we hiervan een lang spoor maken:

    live_loop :melon_trail do
      x, y, z = mc_location
      mc_set_block :melon, x, y-1, z
      sleep 0.125
    end

Nu, spring nu naar Minecraft, zorg ervoor dat je in de vliegende-modus bent (2 keer spatie indien niet) en vlieg over de hele wereld. Kijk achter je om een mooi parcours van meloen blokken te zien! Kijk wat voor gedraaide patronen je in de lucht kan maken.

## Minecraft Live Coderen

Wie in de laatste maanden de zelfstudie (tutorials) heeft gevolgd zal nu wel behoorlijk onder de indruk zijn. Het spoor van meloenen is dan ook cool, maar het strafste deel van het voorgaande voorbeeld is dat je `live_loop` kan gebruiken met Minecraft! Als je `live_loop` niet kent, het is Sonic Pi’s magische eigenschap die geen enkele andere programmeertaal heeft. Het staat je toe verschillende “loops” tezelfdertijd af te spelen, en deze tezelfdertijd ook aan te passen terwijl zij afspelen. Ze zijn heel krachtig en leuk. Ik gebruik `live_loop` om live muziek te spelen in nachtclubs met Sonic Pi. Dj’s gebruiken disc’s en ik gebruik `live_loop`s :-) Maar vandaag gaan we zowel muziek als Minecraft live coderen.

Laten we beginnen. Voer de bovenstaande code in en begin weer met het maken van uw meloen parcours . Nu, zonderde code te stoppen , wijzigen `:melon` naar `:brick en klik afspelen. En hupsaké, je maakt nu een parcours van baksteen. Hoe eenvoudig was dat! Zetten we er wat muziek bij? Ook gemakkelijk. Probeer dit:

    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

Nu, verander de code terwijl dit afspeelt. Verander de blok type’s - probeer `:water`, `:grass` of jouw favoriete blok type uit. Probeer ook de waarde van de cutoff te wijzigen van `70`naar `80`en nog hoger tot `100`. Leuk niet?

## Waardoor het allemaal samen valt

Laten ons nu alles wat we tot hiertoe hebben gezien combineren, met nog een extra vleugje magie. En we combineren onze teleportatie met het blok plaatsen en met de muziek om tot een Minecraft Muziek Videoclip te komen. Wees niet bezorgd dat je niet alles begrijpt, typ het in en speel ermee door sommige waarden te veranderen terwijl het live afspeelt. Veel plezier en tot een volgende keer…

    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

# - Bizet Beats

Na onze korte excursie vorige maand, naar de fantastische wereld van het coderen van Minecraft met Sonic Pi , gaan we opnieuw de muzikale toer op. Vandaag gaan we een klassieke opera dansstuk rechtstreeks naar de 21ste eeuw katapulteren met behulp van de ongelofelijke krachtt van code.

## Schandalig en Disruptief

Laten we door de teletijdmachine terugkeren naar het jaar 1875. Een componist Bizet genaamd heeft net zijn laatste opera Carmen afgewerkt. Zoals het helaas dikwijls gaat met vernieuwende muziek ,sloeg het bij het publiek niet aan wegens te verschillend en te uitbundig. Helaas stierf Bizet 10 jaar voordat deze opera een internationaal succes werd en één van de meest beroemde en gespeelde opera’s aller tijden werd. Uit sympathie voor deze tragedie gaan we één van de hoofdthema’s van Carmen in een moderne muziekstijl gieten die voor de meeste mensen in deze tijd ook te “anders” is: live gecodeerde muziek!

## De Habanera decoderen

Om deze volledige opera zou in deze oefening een te grote uitdaging zijn, laten we daarom ons op één van de meest beroemde delen focussen- de baslijn van de Habanera:

Dit kan uiterst onleesbaar lijken als je geen muziek hebt gestudeerd .Als programmeurs kunnen wij muzieknotatie zien als gewoon een andere vorm van code.Hiermee geeft u instructies aan een musicus in plaats van een computer. Daarom moeten wij een manier bedenken om het te decoderen.

## Noten

De noten zijn van links naar rechts gerangschikt zoals de woorden op uw scherm,maar hebben ook verschillende plaatsing in hoogte.* De hoogte in de partituur geeft de toonhoogte weer.* Hoe hoger de noot in de partituur staat, hoe hoger de noot klinkt.

Hoe we in Sonic Pi de toonhoogte van noten moeten veranderen, weten we al - ofwel gebruiken we getallen zoals `play 75` en `play 80` of we gebruiken de naam van de noot: `play :E` en`play :F`. Gelukkig vertegenwoordigt elk van de verticale posities van de partituur de naam van een specifieke noot. Neem een kijkje naar deze handige opzoek tabel:

## Rusttijden

Partituren zijn een zeer rijke en expressieve soort code waarmee je verschillende uiteenlopende zaken kan communiceren.Het zal dan ook niet verbazen dat partituren jou niet alleen vertellen welke noten je moet spelen, maar ook waar je geen noten mag spelen. In het programmeren is dat te vertalen naar het idee van `nil` of `null` - de afwezigheid van een waarde. Met andere woorden, een noot niet spelen is zoals een noot die afwezig is.

Als je de partituur aandachtig bekijkt zal je zien dat deze een combinatie van zwarte punten met lijnen bevat de de te spelen noten vertegenwoordigen, en kronkelende dingen die de rusttijden vertegenwoordigen. Gelukkig heeft Sonic Pi een handige manier om een rusttijd aan te geven: `:r`, dus als we `play :r` afspelen, speelt deze eigenlijk stilte af! We kunnen ook `play :rest` schrijven, `play nil` of `play false` die allemaal evengoed een rusttijd vertegenwoordigen.

## Ritme

Tenslotte nog een laatste manier om de noten te ontcijferen: de timing van de noten. In de originele partituur zal je zien dat de noten verbonden zijn met dikke lijnen die men waardestrepen noemt. De tweede noot heeft twee lijnen in deze waardestreep wat betekent dat deze noot een zestiende van een tel aanhoudt.De andere noten hebben een enkel waardestreepje, wat wil zeggen dat deze een 8-ste van een tel aanhouden. De rest heeft twee krullige lijnen, vlagjes, die willen zeggen dat deze ook een 16-de van een tel zijn.

Als we trachten nieuwe zaken te ontcijferen, is het handig om alles eenvormig te maken om zo patronen en verbanden te kunnen zien. Bijvoorbeeld, als we onze notenschrift in louter zestiende noten zouden herschrijven, kan je zien dat ons notenschrift verandert in een opeenvolging van noten en rusttijden.

## De Habanera Hercoderen

We staan nu op het punt om te beginnen met het vertalen van deze baslijn naar Sonic Pi. Laten we deze noten en rusttijden in een ring coderen:

    (ring :d, :r, :r, :a, :f5, :r, :a, :r)

Laten we eens kijken hoe dit klinkt. Gooi het in een live loop en “tick” erdoor heen:

    live_loop :habanera do
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end

Fantastisch, die herkenbare riff komt door jouw luidsprekers meteen tot leven. Het kostte veel moeite om hier te komen, maar het was het waard - high five!

## Moody Synths

Nu we de baslijn hebben, gaan we de sfeer van de opera recreëren. Een synth om uit te proberen is `:blade` welke een stemmige, jaren 80 stijl, synth lead is. We proberen deze met de beginnoot `:d`en laten deze door een slicer en een reverb passeren:

    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

Probeer nu de andere noten in de baslijn: `:a`en `:f5`. Denk eraan, je hoeft niet op stop te drukken, je hoeft enkel de code te veranderen terwijl de muziek afspeelt en op afspelen de drukken. Probeer ook verschillende waarden uit voor de `phase:` opt van de slicer uit zoals `0.5`, `0.75`en `1`.

## Waardoor het allemaal samen valt

Ten slotte combineren we alle ideeën die we tot dusver hebben gezien in een nieuwe remix van De Habanera. Je zal opmerken dat ik een ander deel van de baslijn in een commentaarlijn heb gestoken. Eens je alles in een nieuwe buffer hebt getypt, druk je op afspelen om de compositie te horen. Nu, zonder op stop te drukken ga je de tweede regel uitcommentariëren door de # te verwijderen en opnieuw op afspelen te drukken, - hoe prachtig is dat!. Probeer zelf nog het een en ander en veel plezier ermee.

    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

# - Word een Minecraft VJ

Iedereen heeft ooit Minecraft gespeeld. Je zal allemaal verbazingwekkende structuren gebouwd hebben, sluwe vallen ontworpen hebben en zelfs cart lines hebben uitgewerkt met hun bijbehorende redstone schakelaars. Hoeveel van jullie hebben al een optreden gedaan met Minecraft? Wedden dat je niet wist dat je Minecraft kunt gebruiken om ongelofelijke beelden af te spelen net zoals een professionele VJ dat doet.

Als de muis de enige manier was om Minecraft te modificeren, had je het waarschijnlijk moeilijk om de dingen vlug genoeg veranderd te krijgen. Gelukkig komt jouw Raspberry Pi met een versie van Minecraft dat met behulp van code kan gecontrolt worden. Er is ook een app bij die Sonic Pi heet, die Het coderen van Minecraft niet alleen makkelijk, maar ook plezierig maakt.

In het artikel van vandaag gaan we jou enkele van de tips en trucjes tonen, die we hebben gebruikt bij optredens in nachtclubs en podia over de hele wereld.

Laten we starten…

## Starten

Laten we eerst een opwarmertje doen, en even terug keren naar de basis. Vooraleerst, doe je Raspberry Pi open en start zowel Minecraft als Sonic Pi op, creëer een nieuwe wereld, en kies in Sonic Pi een verse buffer en schrijf deze code:

    mc_message "Let's get started..."

Sla de afspelen toets aan om het bericht te zien in het Minecraft-venster. Ok, we zijn klaar om te starten. We gaan wat pret maken…

## Zandstormen

Wanneer we Minecraft gebruiken om visuals mee te maken, houden we in gedachte dat we iets leuk om naar te kijken maken als zowel makkelijk uit code kunnen genereren. Een leuke truc is een zandstorm creëren door zandblokken uit de lucht te laten vallen. Daarvoor hebben we een aantal basis fns nodig:

`sleep` - voor het invoegen van een vertraging tussen acties `mc_location` - om onze huidige lokatie te vinden `mc_set_block`- om de zandblokken op een bepaalde plaats te zetten `rrand` - om ons toe te laten random waarden binnen een bepaald bereik te genereren `live_loop` - om ons toe te laten een constante stroom aan regen te maken

Als je niet vertrouwd bent met een van de ingebouwde fns zoals `rrand`, typ het woord in je buffer, klik erin en gebruik de combinatie `control-i` op je toetsenbord om de ingebouwde documentatie op te roepen. Alternatief kan je ook navigeren naar de lang tab in het hulpsysteem en zoek fns op, tussen al de andere leuke dingen die je kan doen.

Laat het een beetje regenen vooraleer je de zandstorm op volle kracht zet. Pluk je huidige locatie en gebruik deze om in de buurt een paar zandblokken in de lucht te plaatsen:

    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

Wanneer je Afspelen aanslaat, moet je misschien een beetje rondkijken om zicht te hebben op de vallende blokken vermits hun zichtbaarheid afhangt van jouw kijkrichting. Geen nood als je hun val net gemist hebt, klik gewoon terug op Afspelen voor een nieuwe partij zandregen- zorg er gewoon voor dat je in de juiste richting kijkt!

Laten we even kijken wat hier gaan de is. In de eerste regel bemachtigde we de coördinaten van de huidige locatie van Steve via de `mc_location` en plaatsten we deze in de variabelen `x`, `y`, en `z`. Op de volgende regels gebruikten we `mc_set_block` fn om wat zand te plaatsen op de zelfde coördinaten als die van Steve, met wat aanpassingen. We kozen dezelfde x coördinaat , een y coördinaat 20 blokken hoger en achtereenvolgens een groter z coördinaat zodat het zand niet ver van Steve naar beneden valt.

Waarom nemen we deze code niet over om hier wat mee te gaan spelen? Probeer meer lijnregels, verander de rusttijden (sleep), probeer `:sand` met `:gravel` te mengen en gebruik verschillende coördinaten? Experimenteer maar en veel plezier ermee!

## Live Loops ontketend

Ok, tijd om een storm te laten woeden door de kracht van de `live_loop` te laten ontketenen - Sonic Pi’s wonderlijke eigenschap die de kracht van het live code-en laat zien- namelijk de code wijzigen terwijl deze loopt!

    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

Hoe leuk! We gaan behoorlijk snel door deze Loop (8 keer per seconde) en bij elke doorloop vinden we opnieuw de locatie van Steve om er dan 3 random waarden bij te genereren:

`xd` - het verschil bij x welke tussen -10 en 10 liggen `zd` - het verschil bij z ook tussen -10 en 10 `co` - een cutoff waarde voor de low pass filter tussen 70 en 130

We gebruiken dan deze random waarden in de fns `synth` en `mc_set_block` die ons vallend zand geven op willekeurige plaatsen rond Steve samen met een regen-achtig geluid van de `:cnoise` synth.

Voor diegene voor wie live loops nieuw zijn - hier begint de pret pas met Sonic Pi. Terwijl de code loopt en het zand naar beneden wordt uitgestrooid, tracht je één van de waarden te veranderen, misschien de rusttijd (sleep) naar `0.25` of de `:sand` block type naar `:gravel. Druk nu opnieuw Afspelen in. En presto veranderde de zaken die je had aangepast zonder de code te hoeven stoppen. Dit is jouw toegangspoort om als een echte VJ aan de slag te gaan. Blijf oefenen en verander hier en daar wat. Hoe verschillend kan jij de visuals maken zonder de code te stoppen?

## Epische blok patronen

Wat tenslotte ook een fantastische manier is om interessante visuals te maken is van een grote muur van een patroon te genereren om naartoe en langsheen te vliegen. Om dit effect te bereiken moeten moeten we ons van het idee van het willekeurig plaatsen van blokken verplaatsen naar deze geordend te plaatsen. We kunnen dit doen door twee sets van iteratie (druk op de hulp-knop om naar sectie 5.2 van de zelfstudie “Iteratie en loops” te navigeren voor meer achtergrondinformatie over iteraties). De gekke `|xd|` achter do betekend dat `xd` achter elke waarde van de iteratie zal worden gezet. De eerste keer zal deze 0 zijn, dan1, dan 2…..enz. Door twee delen iteratie te gaan nesten, kunnen we op deze manier de coördinaten voor een vierkant genereren. We kunnen dan willekeurig blok-types kiezen van een ring van blokken om een interessant effect te bekomen:

    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

Behoorlijk gaaf. Terwijl we hiermee plezier beleven, probeer je `bs.choose` te veranderen naar `bs.tick om van een willekeurig patroon een meer regelmatig patroon te bekomen. Probeer ook de blok-type's te veranderen en de waaghalzen onder ons willen deze misschien ook in een` live_loop` plakken om de patronen automatisch te laten veranderen.

Nu, voor de VJ finale: verander de twee `10.times` naar `100.times` en klik op Afspelen. Kaboom! Een reusachtig en gigantische muur van willekeurig geplaatste bakstenen. Beeld je in hoe lang je daarmee bezig zou zijn geweest indien je dit met de muis zou gedaan hebben! Sla twee keer de spacebar om naar vlieg-modus over te gaan en begin aan een duikvlucht voor geweldige visuele effecten. Maar stop op dit punt nog niet, gebruik je verbeeldingsvermogen voor coole ideeën en gebruik in Sonic Pi de kracht van het coderen om deze werkelijk te maken. Wanneer je voldoende geoefend hebt, dim je de lichten en zet een VJ show voor je vrienden op!

# - Surfen op Random Streams

In deel 4 van deze zelfstudie serie keken we even naar randomiseren terwijl we een aantal broeierige synth-riffs codeerden. Daar randomiseren zo’n belangrijk onderdeel van mijn live-coding DJ-sets is, dacht ik dat het zinvol was om de grondbeginselen ervan in detail te gaan bekijken. Laat ons beginnen surfen op Random Streams!

## Er is geen random

Het eerste wat je moet weten, en wat jou misschien ook verrast, wanneer je met de randomisering functies van Sonic Pi speelt, is dat deze niet écht random zijn. Wat betekent dit? Wel laat ons een paar tests doen. Verbeeld je eerst een getal tussen 0 en1. Onthou deze en verklap deze niet aan mij. Nu laat me raden… was het `0.321567`? Nee? Goh ik ben er blijkbaar toch niet zo goed in. Geef me nog een kans maar vraag deze keer Sonic Pi een nummer te kiezen. Start Sonic Pi v2.7+ en vraag deze een random nummer te genereren, maar ook nu verklap je deze niet aan mij:

    print rand

En dan nu de onthulling… was het `0.75006103515625`? Yes! Ha maar ik merk dat je hier een beetje sceptisch tegenover staat. Misschien was het wel een gelukstreffer. We proberen nog een keer. Druk opnieuw op Afspelen en we zien wel wat we krijgen… Wat? Opnieuw `0.75006103515625`? Dit kan duidelijk geen random zijn! Je hebt gelijk, het is ook geen random.

Wat gebeurt hier? Determinisme is de dure computerwetenschappelijke term die hier kan opgaan.Het betekent gewoon dat het toeval niet bestaat en alles voorbestemd is om te worden. Uw versie van Sonic Pi is voorbestemd om altijd `0.75006103515625` terug te geven. Dit klink misschien helemaal niet nuttig, maar ik verzeker je dat dit één van de meest krachtige delen van Sonic Pi is. Als je hier aan vasthoud zal je leren vertrouwen te schenken aan de deterministische manier van randomisering in Sonic Pi als fundamentele bouwsteen voor jouw composities en live gecodeerde DJ sets.

## Een Random Melodie

Wanneer Sonic Pi opstart, laad het eigenlijk een opeenvolging van 441.000 pre-geregenereerde waarden in het geheugen op. Wanneer je een random functie zoals `rand` of `rrand` oproept, wordt deze stroom van random waarden gebruikt om jouw resultaat te regenereren. Elke oproep naar een random functie verbruikt een waarde van deze stroom. Daarom zal de 10-de oproep naar zo’n random functie, de 10-de waarde van de stroom gebruiken. Iedere keer je op de Afspelen toets drukt zal de stroom voor die doorloop gereset worden. Daarom ook kon ik het resultaat van `rand` voorspellen en was de ‘random’ melodie ook elke keer dezelfde. Ieders versie van Sonic Pi gebruikt dezelfde random stream, wat ook belangrijk is als we elkaars code onderling gaan delen.

Laten we deze kennis te gebruiken om een herhalende willekeurige melodie te genereren:

    8.times do
     play rrand_i(50, 95)
     sleep 0.125
    end

Typ deze in een lege buffer en klik Afspelen? Je hoort een melodie die bestaat uit ‘random’ noten tussen 50 en 95. Wanneer deze uitgespeeld is, klik je opnieuw op Afspelen opnieuw om exact dezelfde melodie te hoeren spelen.

## Handige randomisering Functies

Sonic Pi wordt geleverd met een aantal handige functies voor het werken met de random stream. Hier is een lijst met enkele van de meest nuttige:

`rand` - geeft gewoon de volgende waarde van de stream weer `rrand` - geeft een random waarde binnen een bereik weer `rrand_i` - Geeft een random geheel getal binnen een bereik weer `one_in` - Geeft true of false weer met de gegeven probabiliteit `dice` - Immiteerd het rollen van een dobbelsteen en geeft waarden tussen 1 en 6 weer `choose` - Kiest een willekeurige waarde uit een lijst

Bekijk hun documentatie in het Help-systeem voor meer informatie en voorbeelden.

## Resetten van de Stream

Terwijl de mogelijkheid om het herhalen van een fragment met gekozen noten essentieel is om jouw riff te kunnen spelen op de dansvloer, is het misschien niet de riff die je wou. Zou het niet geweldig zijn moesten we een aantal verschillende riffs kunnen uitproberen om dan de beste ervan te kunnen uitkiezen? Hier gaat de toverdoos open.

We kunnen de stream met de fn ‘use_random_seed’ handmatig instellen. In Computerwetenschap, is random seed een startpunt waaruit een nieuwe stream van random waarden kunnen beginnen kiemen en bloeien. We proberen dit:

    use_random_seed 0
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

Geweldig, we krijgen de eerste drie noten van onze random melodie hierboven: ‘84’, ‘83’ en ‘ 71’. We kunnen de seed naar ierts anders veranderen. Laat ons zeggen deze:

    use_random_seed 1
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

Interessant, we krijgen ‘83’, ‘71’ en ‘ 61’. Je merkt hierbij misschien ook op dat de eerste twee cijfers hier, dezelfde zijn als de laatste twee in het vorige voorbeeld - dit is geen toeval.

Vergeer niet dat de random stream gewoon een gigantisch lijst is van vooraf op een rol gezette waarden is. Random seed gebruiken is gewoon een verspringen naar een plaats in de lijst. Een andere manier om ons dit voor te stellen is te denken aan een gigantische deck van door elkaar geschudde speelkaarten. Gebruik maken van random seed is als het openklappen van deze deck op een nauwkeurig punt. Het fabuleuze gedeelte hier is dat precies de mogelijkheid om rond te springen in de random stream, dit ons een krachtig instrument geeft wanneer we muziek maken.

Laten we onze random melodie van 8 noten nog eens opzoeken met de kracht van die nieuwe stream resetting, maar laten we er ook een live loop in gooien zodat we ermee kunnen experimenteren terwijl de code loopt:

    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

Nu, terwijl deze nog speelt, verander je de seed waarde van `0`naar iets anders. Probeer `100`, en wat dacht je van `999`. Probeer ook je eigen waarden, experimenteer en speel er wat mee - en kijk welke seed de riff regenereerde die jij het leukst vindt.

## Waardoor het allemaal samen valt

De tutorial van deze maand was een behoorlijk technische duik in hoe de functionaliteit van de randomisatie in Sonic Pi werkt.Hopelijk gaf het jou wat inzicht hoe dit in z’n werk gaat en hoe je deze op een vertrouwde manier kan gaan gebruiken om repeteerbare patronen in jouw muziekstukken te creëren. Het is belangrijk je erop te wijzen dat je repeteerbare randomisatie overal je maar wil kan gebruiken. Je kan bijvoorbeeld de amplitude van noten randomiseren, de maat van het ritme, de hoeveelheid galm (reverb), de synth die je gebruikt, de mix van de FX, enz. enz. In de toekomst gaan we uitgebreid kijken naar sommige van die toepassingen, maar momenteel geef jou nog even dit voorbeeld.

Typ het volgende in een lege buffer, toets Afspelen, en begin dan links en rechts de seeds te veranderen, duw opnieuw op Afspelen (terwijl het nog speelt) en onderzoek welke verschillende geluiden, ritmes en melodieën die je kan maken. Wanneer je iets lekkers gevonden hebt, probeer dan het seed getal te onthouden, zodat je die later opnieuw kan gebruiken. Als je tenslotte een aantal leuke seeds gevonden hebt, nu kan je voor je vrienden een live coded optreden geven door gewoon te switchen tussen jouw favoriete seeds om een compleet muziekstuk te creëren.

    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

# - Jouw Geluid Controllen

Tot zover hebben we in deze serie de focus gelegd op het triggeren van geluiden. We hebben geleerd dat we de, in Sonic Pi, ingebouwde synth’s met `play` of `synth` kunnen triggeren en vooraf opgenomen samples triggeren met `sample`. We hebben ook geleerd hoe we deze getriggerde klanken in een studio FX kunnen steken door middel van het `with_fx` commando. Combineer deze met het ongelofelijk nauwkeurige timing systeem van Sonic Pi en je kan een breed scala klanken,beats en riff’s produceren. Maar zodra je een zorgvuldig geselecteerde klank opties hebt uitgekozen en deze hebt getriggerd, is er geen mogelijkheid om deze klank te veranderen terwijl deze speelt, juist? Neen hoor! Vandaag gaan we iets machtig leren, hoe een lopende synth controllen.

## Een Basis Klank

Laat ons even een leuke eenvoudige klank maken. Start Sonic Pi en typ in een nieuwe buffer het volgende:

    synth :prophet, note: :e1, release: 8, cutoff: 100

Druk nu op de Afspeel-knop bovenaan links om dan een een mooie rommelend synth-geluid te mogen horen. Doe dit nog maar een paar keer om het in de vingers te krijgen en druk op Afspelen. Ok, klaar? Nu beginnen we het te controllen!

## Synth Nodes

Een weinig bekende functie in Sonic Pi is dat de fns `play`, `synth` en `sample`, een zogenaamde `SynthNode` opgeven, die een lopende klank vertegenwoordigd. Je kan zo’n `SynthNode` vastleggen door een standaard variabele te gebruiken en deze later te gaan controllen. We kunnen bijvoorbeeld de waarde van de `cutoff:` opt na 1 tel veranderen:

    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    control sn, cutoff: 130

Laten we de verschillende regels op zijn beurt even bekijken:

Ten eerste triggeren we de `:prophet` synth door de `synth` fn zoals gewoonlijk te gebruiken. We spelen het resultaat aan een variabele door genaamd `sn`. We zouden deze variabele ook een totaal andere naam hebben kunnen geven zoals `synth_node` of `kevin` , de naam speelt geen rol. Het is wel belangrijk dat deze voor jou een betekenis heeft als je een performance geeft en voor de mensen die jouw code lezen. Ik koos nu voor `sn` omdat dit een mooi geheugensteuntje is naar synth node.

Op regel 2 hebben we het standaard `sleep` commando. Het doet niks bijzonders, het vraagt de computer enkel om één tel te wachten alvorens verder te gaan naar de volgende regel.

Op regel 3 begint de pret met control. Hier gebruiken we de `control` fn, om onze lopende `synth_node` te vertellen, de cutoff waarde naar `130` te veranderen. Als je Afspelen klikt, hoor je de`:prophet` synth zoals daarvoor, maar na 1 tel zal deze verschuiven naar een meer heldere klank .

Moduleerbare Opties

De meeste van Sonic Pi’s synths en FX opts kunnen veranderd worden nadat ze getriggerd zijn. Dit is echter niet voor allen het geval. Bijvoorbeeld, de envelop opts `attack:`, `decay:`, `sustain:` and `release:` kunnen alleen ingestelt worden bij bij het triggeren van de synth. Uitzoeken welke opts wel en welke niet kunnen veranderd worden is heel makkelijk, ga gewoon naar de documentatie voor de gegeven synth of FX en scroll naar beneden naar de afzonderlijke beschrijving van de opties.In de onderste regel vind je dan “Kan veranderd worden tijdens het afspelen” of “Kan niet veranderd worden eens ingesteld”. De documentatie voor de `:beep` synth maakt duidelijk dat het niet mogelijk is de `attack:` opt te veranderen eens ingesteld:

Standaard instelling: 0 Moet nul of groter dan nul zijn Kan niet worden aangepast eens ingesteld Geschaald met huidige BPM waarde

## Meerdere veranderingen

Als een synth eenmaal loopt ben je niet beperkt tot slechts 1 verandering - je kunt veranderingen blijven doen zoveel je wilt. bijvoorbeeld, we kunnen onze ‘:prophet’ veranderen in een generator van een reeks accoordtonen (dat is een arpeggio, arpeggio generator =arpeggiator) door het volgende te doen:

    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

In dit stukje code kunnen we een aantal extra zaken toevoegen. Ten eerste hebben we een nieuwe variabele, genaamd `notes`, gedefinieerd, die de noten bevat die we graag willen doorlopen (een arpeggiator is gewoon een chique naam voor datgene waarin een lijst van noten in een volgorde wordt doorlopen) Ten tweede hebben we onze éénmalige oproep naar `control`, vervangen door een iteratie om deze 16 keer aan te roepen. In elke oproep naar `control`, hebben we een `:tick` -en we door onze ring van `notes`, die automatisch herhaald worden eens we aan het einde ervan gekomen zijn (dankzij de sublieme kracht van Sonic Pi’s rings) Voor wat variatie probeer je `.tick` door `.choose` te vervangen, en bekijk of je hier een verschil kan horen.

Merk op dat we meerdere opts tegelijk kunnen veranderen. Probeer de control regel naar het volgende te wijzigen en hoor nu het verschil:

    control sn, note: notes.tick, cutoff: rrand(70, 130)

## Sliden

Wanneer we een `SynthNode` controllen, reageert die precies op tijd vanuit de waarde van de opt naar de nieuwe waarde, alsof je een knop indrukte, of een schakelaar aanzette om de verandering aan te brengen. Dit kan ritmisch en percussief klinken, zeker als de opt een aspect van de klankkleur bepaalt zoals de `cutoff:`. Maar soms wil je helemaal niet dat de verandering in een knip gebeurd, maar dat deze langzaam aan overgaat van de huidige waarde naar de nieuwe waarde, alsof je langzaam een schuifregelaar bewoog. Natuurlijk kan Sonic Pi dit ook, door gebruik te maken van de `_slide:` opts.

Elke opt die gewijzigd kan worden heeft een overeenkomstige `_slide:` opt waarmee je de slide tijd mee kan instellen. Bijvoorbeeld, `amp:` heeft `amp_slide:` en `cutoff:` heeft `cutoff_slide:`. Deze slide opts werken een beetje anders dan de andere opts, doordat zij de synth noot opdraagt, hoe deze zich moeten gaan gedragen de volgende keer dat ze gecontrold wordt. Laten we hier even naar kijken:

    sn = synth :prophet, note: :e1, release: 8, cutoff: 70, cutoff_slide: 2
    sleep 1
    control sn, cutoff: 130

Merk hierbij op dat we hetzelfde voorbeeld genomen hebben, maar hier hebben we `cutoff_slide:` toegevoegd. Dit betekent dat de volgende keer; de `cutoff:` opt wordt gecontrolt. Het neemt 2 beats (tellen) in beslag om te sliden vanuit de huidige waarde naar de nieuwe waarde. Daardoor hoor je, wanneer we `control` gebruiken, de cutoff sliden van 70 naar 130. Het creëert een interessante dynamiek in het geluid. Probeer nu de `cutoff_slide:` tiid te veranderen naar een kortere waarde zoals 0.5 en door een langere waarde zoals 4 om te zien hoe dit de klank verandert. Denk eraan, je kan elke modificeerbare opt op deze manier sliden, en elke `_slide:` waarde mag helemaal anders zijn. Zo kan de cutoff langzaam sliden, de amp snel sliden en de pan daar ergens tussenin sliden, zoals jij dit wil …

## Waardoor het allemaal samen valt

Laat ons naar een korter voorbeeld kijken dat ons de kracht toont van het controllen van synths nadat ze getriggerd zijn. Merk hierbij op dat ook FX zoals synths kan sliden maar met een iets andere syntax. Bekijk hoofdstuk 7.2 van de ingebouwde handleiding voor meer informatie omtrent het controllen van FX .

Kopieer de code naar een overgebleven buffer en luister hier naar. Stop niet en speel een beetje met de code. Verander de slide tijd, verander de noten, de synth, de rusttijd (sleep) en zorg dat je deze kan veranderen tot iets compleet anders!

    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

# - De maat houden

Vorige maand hebben we in deze serie een diepe duik genomen in het randomiseer systeem dat Sonic Pi ondersteund. We gingen na hoe we dit kunnen gebruiken om op deterministische wijze, nieuwe lagen van dynamische controle op onze code, uit te oefenen.

## De beat tellen

Wanneer we muziek maken willen we soms dingen gaan doen die afhangen van het tempo en de beat. Sonic Pi heeft een speciaal systeem dat de beat telt, genaamd `tick`, om je de precieze controle te geven over wanneer een beat daadwerkelijk optreedt en zelfs meerdere beats met hun eigen tempo ondersteunt.

We spelen hier nu even mee, om de beats te laten toenemen hoeven we gewoon `tick` aan te roepen. Open een lege buffer, typ het volgende en druk op Afspelen:

    puts tick #=> 0

Dit geeft je de huidige beat: `0`. Merk op dat zelfs wanneer je de Afspeel-knop herhaaldelijk indrukt, altijd `0` zal weergegeven worden. Dat komt omdat bij elke afspeel-commando het tellen van de beat van 0 start. We kunnen echter wanneer het afspelen nog actief is, de beat omhoog laten gaan, zoveel maal we zelf willen:

    puts tick #=> 0
    puts tick #=> 1
    puts tick #=> 2

Telkens je het symbool `l#=>` aan het einde van een regel code ziet, betekend dit dat deze regel de tekst logt in het logvenster rechts. Bijvoorbeeld `puts eenderwat #=> 0 betekent dat de code` puts eenderwat `0`zal uitprinten naar het log op het moment dat dit in het programma voorkomt.

## De beat nagaan

We hebben gezien dat `tick` twee dingen doet. Het verhoogt (voegt toe) en geeft als resultaat de huidige beat. Soms willen we gewoon kijken naar de huidige beat zonder deze te verhogen. Dat kunnen we doen met `look`:

    puts tick #=> 0
    puts tick #=> 1
    puts look #=> 1
    puts look #=> 1

In deze code tick-en we de beat twee keer en roepen we `look` twee maal op. We zien de volgende waarden het log verschijnen: `0`, `1`, `1`, `1`. De eerste twee `tick`s gaven `0`en `1` zoals verwacht weer. daarna gaven de twee `look`s de laatste waarde van de beat weer, die `1`was.

## Ringen

Nu kunnen we dus de beat verhogen door middel van `tick`en deze nagaan door `look`. Maar wat nu? We hebben nog iets nodig om te laten tick-en. Sonic Pi gebruikt ringen om riffs, melodieën en ritmes te vertegenwoordigen, en het tick systeem is speciaal ontwikkeld om nauw met hen samen te werken. In feite hebben ringen hun eigen dot versie van `tick`,die twee dingen doet. Ten eerste functioneert deze als een gewone tick en verhoogt ook de beat.Ten tweede zoekt die de waarde van de ring op waarbij de beat als index wordt gebruikt. Laten we hier even naar kijken:

    puts (ring :a, :b, :c).tick #=> :a

`.tick` ‘is een speciale dot versie van ‘tik’, die de eerste waarde van de ring geeft `:a`. We kunnen elke waarden in de ring oppikken door `.tick` meerdere keren op te roepen:

    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

Neem nu een kijkje in het log en je zal `:a`, `:b`, `:c` zien en dan `:a` opnieuw. Merk op dat `look` `3` weergeeft. Een oproep naar `.tick` zal handelen als een gewone oproep naar `tick`, zij verhogen de beat hier.

## Een Live Loop Arpeggiator

De sterke kant hiervan komt naar boven als je `tick` mixt met `ring` en `live_loops`s. Wanneer zij gecombineerd worden, hebben we ons gereedschap om een eenvoudige arpegiator te bouwen,en om deze te begrijpen. We hebben maar vier dingen nodig:

Een ring die de te doorlopen noten bevat. Een middel om de beat te verkrijgen en te verhogen. De mogelijkheid om een noot te spelen volgens de huidige beat. Een loop structuur waarin de arpegiator zich herhaalt.

Deze concepten vind je in de volgende code terug:

    notes = (ring 57, 62, 55, 59, 64)
    live_loop :arp do
      use_synth :dpulse
      play notes.tick, release: 0.2
      sleep 0.125
    end

Laten we een kijkje nemen naar elke regels. Ten eerste definiëren we onze ring noten, die we continue laten afspelen. Dan maken we onze `live_loop` die `arp` heet, en die voor ons de loop doet. Elke cyclus van de `live_loop` stellen we onze synth in op `:dpulse´, om vervolgens de volgende noot in onze ring te spelen met behulp van` ;tick`. Denk eraan dat dit onze beat-teller zal verhogen en onze laatste beat waarde zal gaan gebruiken als index in onze noten ring. Tenslotte, wachten we één achtste van een tel alvorens opnieuw te gaan loop-en.

## Meerdere simultane beats

Belangrijk om weten is, is dat `tick` lokaal werkt tegenover `live_loop`. Dit betekent dat elke `live_loop` z’n eigen individuele beat-teller heeft. Dit is krachtiger dan het hebben van een globale metronoom en beat. Laten we dit in actie zien:

    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

## Botsende Beats

Een grote oorzaak van verwarring met het tick systeem van Sonic Pi is wanneer men meerdere ringen willen tick-en in de zelfde `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

Hoewel elke ‘live_loop’ zijn eigen onafhankelijke beat teller heeft, roepen we `.tick` twee keer op binnen dezelfde `live_loop`. Dit betekent dat de beat twee keer wordt verhoogd bij elke cyclus die doorlopen wordt. Op die manier kunnen interessante poly-ritmes ontstaan, maar dikwijls wil je dit ook helemaal niet. Je kan dit op twee manieren oplossen. De ene oplossing is een manuele oproep naar `tick` aan de start van de `live_loop` om dan `.look` te gebruiken om de huidige beat in in elk van de `live_loop`’s op te zoeken. De tweede oplossing is elke `.tick` een unieke naam te geven zoals bvb `.tick(:naam1)`. Sonic Pi zal dan een aparte beat-teller maken en gebruiken voor elke, door jou benoemde `.tick`. Hiermee kan je zoveel verschillende beats werken als je maar wil! Zie sectie 9.4 over benoemde tick’s in de ingebouwde handleiding voor meer informatie.

## Waardoor het allemaal samen valt

Laat ons de opgestoken kennis over `tick`s, `ring`s en `live_loop`s samenvoegen in een leuk voorbeeld. En ook deze keer mag je dit voorbeeld ook niet als een afgewerkt stuk zien. Verander hier en daar de waarden, en ontdek zo wat je er kan uitkrijgen. Tot volgende keer…

    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

# - Het snijden van een sample

Een hele tijd terug in aflevering 3 van deze Sonic Pi serie, keken we hoe we één van de meest bekende drum breaks aller tijden konden loop-en, stretchen en filteren: de Amen Break. In deze tutorial gaan we nog een stapje verder en gaan we zien hoe we de sample kunnen opknippen, de stukken door elkaar te schudden en deze in een andere volgorde weer aan elkaar te lijmen. Misschien klinkt dit allemaal wat raar nu, maar maak je geen zorgen, het zal je snel allemaal duidelijk worden, en je zal deze techniek snel meester zijn en deze in de toekomst gebruiken in je live gecode set .

## Geluid als data

Voor we eraan beginnen, kijken we even hoe we het gebruik van sample’s beter kunnen begrijpen. Ondertussen hebben jullie hopelijk al gespeeld met de krachtige sampler van Sonic Pi. Indien niet, start Raspberry Pi, laad Sonic Pi op, en typ het volgende in een lege buffer om de drum-sample te kunnen horen:

    sample :loop_amen

Een opgenomen geluid wordt simpelweg uitgedrukt in data, veel nummers tussen -1 en 1 zijn dat die de pieken en dalen van een geluidsgolf vertegenwoordigen. Als we deze cijfers in volgorde kunnen reproduceren, krijgen we het originele geluid terug. Maar wat houdt ons tegen om deze in een andere volgorde te gaan afspelen en hierbij een nieuw geluid te creëren?

Hoe zijn samples eigenlijk opgenomen? Dat is eigenlijk vrij eenvoudig als u eenmaal de fundamentele fysica van geluid begrijpt. Bij het produceren van een klank,bijvoorbeeld door op een trommel te slaan, reist het geluid door de lucht,op een zelfde manier het wateroppervlak rimpels maakt als je er een steentje in gooit. Als deze golven jouw oren bereiken, zal jouw trommelvlies hierop reageren en zullen deze bewegingen omgezet worden naar de klank die jij dan hoort. Als we een geluid willen opnemen en terug willen afspelen moeten we deze geluidsgolven capteren, opslaan en reproduceren. We kunnen dit bijvoorbeeld met een microfoon, die net als een trommelvlies reageert en heen en weer zal bewegen zodra een geluidsgolf het membraan raakt. De microfoon registreert deze beweging en zet deze om tot een minuscuul elektrisch signaal dat op zijn beurt vele malen per seconde wordt gemeten.Deze metingen worden dan weergegeven als een reeks getallen tussen -1 en 1.

Als we geluid zouden visualiseren zou deze een simpele grafiek zijn van datagegevens met tijdsverloop op de x-as en de bewegingen van de microfoon/luidspreker met waarden tussen -1 en 1 op de y-as. Je kan, bovenaan het diagram, een voorbeeld van zo’n grafiek zien.

## Een deel van een sample afspelen

Dus, hoe kunnen we dan Sonic Pi zo coderen dat deze een sample in een andere volgorde afspeelt? Om een antwoord op deze vraag te kunnen geven moeten we een kijkje nemen naar de `start:` en`finish:` opts voor `sample`. Deze laten ons toe de start en eindposities voor de weergave van een sample te bepalen. De waarden voor deze opts liggen tussen `0` en`1` waarbij `0` staat voor de de start van de sample en `1` het einde ervan is. Dus als we de eerste helft van de Amen Break willen spelen moeten we de `finish:` zetten op `0.5`:

    sample :loop_amen, finish: 0.5

We kunnen ook een `start:` toevoegen om een nog kleiner stukje van de sample te kunnen spelen:

    sample :loop_amen, start: 0.25, finish: 0.5

Voor de lol kunnen we de waarde van `finish:` laten vallen vòòr de waarde van `start:` om de selectie achterstevoren te laten afspelen:

    sample :loop_amen, start: 0.5, finish: 0.25

## Het afspelen van een sample herordenen

Nu we weten dat een sample een simpele lijst is van getallen, die we in eender welke volgorde kunnen laten afspelen en we ook weten hoe we een bepaald deel van de sample kunnen afspelen, kunnen we na aan de slag gaan en een sample in de verkeerde volgorde gooien en afspelen.

Laten we onze Amen break nemen en deze in 8 gelijke stukken verdelen en de stukken verschuiven. Kijk even op het diagram: bovenaan A) geeft de grafiek van onze originele sample weer. In 8 stukjes geknipt geeft ons B) , merk op dat we elk stukje een andere kleur hebben gegeven om deze te kunnen onderscheiden. Je ziet bovenaan de waarde van start en einde ,van elk stukje. En tenslotte is C) een mogelijke herordening van de stukjes. Deze kunnen we als een nieuwe beat afspelen. Laten we even deze code bekijken om dit te gaan doen:

    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

We kiezen een willekeurige segment om af te spelen welke een willekeurig getal tussen 0 en 7 is (voor de 8 stukken, we tellen vanaf 0!) Hiervoor heeft Sonic Pi een handige functie: `rand_i(8)`. Vervolgens bewaren we deze willekeurige segment-index in de variabele `slice_idx`. Definiëren we onze `slice_size` die 1/8 is of 0,125 is. De `slice_size` is noodzakelijk om onze ‘slice_idx’ te converteren naar een waarde tussen 0 en 1 zodat we deze kunnen gebruiken als onze `start:` opt. We berekenen de beginpositie ‘ door de ‘slice_idx’ met ‘slice_size’ te vermenigvuldigen . We berekenen de eind-positie `f` door de ´slice_size`aan de startpositie` s`toe te voegen. We kunnen nu deze sample-slice afspelen door de waarden van` s`en` f`, in de` start:`en` finish:`opts voor` sample`te steken. Voordat we het volgende segment spelen moeten we weten hoe lang de` sleep`is welke de duurtijd is van ons sample segment. Gelukkig heeft Sonic Pi ons voorzien van` sample_duration`welke dezelfde opts heeft als` sample`en ons zijn duurtijd kan weergeven. Dus, door het passeren van` sample_duration`aan onze` start:`en` finish:`kennen we de duur van elke slice. We steken deze code in een` live_loop` zodat we verder nieuwe random slices kunnen uitpikken.

## Waardoor het allemaal samen valt

Laten we alles wat we tot nu toe hebben gezien, met de zelfde aanpak in een laatste voorbeeld combineren, dat demonstreert hoe opgeknipte beats met wat bass het begin van een interessante track kunnen maken . Nu is het jouw beurt - om de onderstaande code als uitgangspunt te nemen en te zien of je deze een eigen twist kan geven om er weer iets helemaal anders van te maken…

    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

# - Codeer een probabilistische Sequencer

In een vorige aflevering van deze Sonic Pi serie, verkenden we de kracht van randomiseren om verscheidenheid,variatie en verassing te kunnen introduceren in onze live gecodeerde nummers en optredens. We plukten bijvoorbeeld willekeurig noten van een bepaalde toonladder, om nooit-eindigende melodieën te creëren. Vandaag gaan we een nieuwe techniek leren, die gebruik maakt van het randomiseren van ritme - probabilistische beats!

## Probabiliteit

Voor we nieuwe beats en synth ritmes beginnen maken, moeten we even kijken naar de basisprincipes van probabiliteit. Het lijkt misschien ingewikkeld, maar het is echt net zo eenvoudig als een dobbelstenen werpen - echt waar! Als je een 6 zijdige dobbelsteen gooit, wat gebeurt er dan? Wel misschien gooi je een 1, 2, 3, 4, 5 of 6 met precies dezelfde kansen. Hierdoor heb je een kans van 1 in 6 van het gooien van een 1. We kunnen ook het gooien van dobbelstenen in Sonic Pi emuleren met de fn ‘dice’ . Laten we eens 8 keer gooien:

    8.times do
      puts dice
      sleep 1
    end

Kijk hoe in het logboek waarden tussen 1 en 6 wordt afgedrukt, alsof we een echte dobbelsteen geworpen zouden hebben.

## Random Beats

Beeld je even in dat je een trommel hebt en dat je elke keer je deze zou slaan, je een teerling zou werpen. Als je één gooit zou je hem slaan en elke worp met een ander getal niet. Je hebt nu een probalistische drummachine met een probabiliteit van 1/6! Laten we eens horen hoe dat klinkt:

    live_loop :random_beat do
      sample :drum_snare_hard if dice == 1
      sleep 0.125
    end

Laat ons even snel elke regel overlopen om er zeker van te zijn dat alles duidelijk is. Eerst creëren we een nieuwe `live_loop` die `:random_beat`heet , en de twee regels tussen `do` en `end`, herhaalt. De eerste regel roept een `sample` aan die een vooraf opgenomen geluidsbestand afspeelt ( `:drum_snare_hard` in dit geval ).Deze lijn heeft echter een special voorwaardelijk einde met de `if` functie. Deze betekent dat de regel enkel wordt uitgevoerd als de declaratie, rechts van de `if` (als), `true`(waar) is. Deze geeft in dit geval `dice == 1` aan. Die roept onze `dice`functie aan dewelke, zoals we reeds zagen, een waarde tussen 1 en 6 zal teruggeven.

## Probabiliteit veranderen

Wie al een rollenspel heeft gespeeld zal al wel vertrouwd zijn met vreemd gevormde dobbelstenen die verschillende reeksen getallen kunnen hebben. Er is bijvoorbeeld de tetraëder-vormige dobbelsteen die 4 zijden heeft en zelfs een 20 zijdige dobbelsteen in de vorm van een icosaëder. Het aantal zijden op de dobbelsteen verandert de kans of waarschijnlijkheid van het rollen van een 1. Hoe minder kanten, hoe meer kans je hebt om 1 te gooien en hoe meer zijden hoe minder waarschijnlijk. Met een 4-zijdige dobbelstenen bijvoorbeeld, is er een kans van één op 4 om een 1 te gooien en met een 20 zijdige dobbelsteen er is één kans op de 20. Gelukkig heeft Sonic Pi de handige ‘one_in’ fn om precies dit te bepalen. Laten we gaan gooien:

    live_loop :different_probabilities do
      sample :drum_snare_hard if one_in(6)
      sleep 0.125
    end

Start de bovenstaande live-loop en je hoort het bekende random ritme. Stop deze nog even niet maar wijzig de `6` naar een andere waarde, zoals `2` of `20` en druk op de `Afspeel` - knop. Merk op dat een lager getal betekent dat je de snare drum vaker hoort en dat hogere cijfers de snare minder zullen triggeren. Je maakt nu muziek met kansberekening!

## Probabiliteit combineren

Echt spannend wordt het wanneer je meerdere samples combineert, die worden geactiveerd met verschillende kansen. Bijvoorbeeld:

    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

Opnieuw, laat de bovenstaande code lopen, en wijzig de probabiliteit, om het ritme te modificeren. Probeer het ook de samples te veranderen om een geheel nieuw gevoel te creëren. Probeer bijvoorbeeld `:drum_cymbal_closed` naar `:bass_hit_c` te veranderen voor extra bass!

## Herhaalbare ritmes

Vervolgens kunnen we gebruik maken van onze oude vriend `use_random_seed` om de willekeurige stroom, na 8 herhalingen opnieuw in te stellen om een regelmatige beat te maken. Typ de volgende code om een meer regelmatig en herhalend ritme te horen. Zodra je de beat hoort, probeer de seed waarde van `1000` naar een ander nummer te wijzigen. Merk op hoe verschillende cijfers, verschillende beats genereren.

    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

Wat ik met dit soort structuren ook graag doe is, de seeds, welke goed klinken,te onthouden en deze te noteren. Op die manier kan ik makkelijk mijn favoriete ritmes opnieuw maken in toekomstige trainingen of voorstellingen.

## Waardoor het allemaal samen valt

Tot slot kunnen we er een random baslijn aan toevoegen om er een mooie melodische inhoud aan te geven. Merk ook op dat we onze pas aangeleerde probabilistische sequentie methode, kunnen gebruiken op synths en samples. Laat het daar zeker ook niet bij, pas de getallen aan, en maak je eigen nummer met de kracht van waarschijnlijkheden!

    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

# - Amplitude Modulatie

Deze maand gaan we een diepe duik nemen in een van Sonic Pi ‘ s meest krachtige en flexibele audio effecten: de `: slicer`. Aan het eind van dit artikel heb je geleerd hoe je de totale omvang van de onderdelen van ons live gecodeerd geluid op een krachtige, nieuwe manieren kan manipuleren. Dit zal je toelaten, nieuwe ritmische en timbrale structuren te creëren en je klankspectrum te verruimen.

## Snij de Amp

Dus, wat doet deze:slicer`FX eigenlijk? Een manier om er naar te kijken is ,dat het net iemand is, die speelt met de volumeknop op de stereoinstallatie of de TV. Laten we eens een kijkje nemen, maar zeker eerst luisteren naar het diepe gegrom van de volgende code die de` :prophet` synth triggeren:

    synth :prophet, note: :e1, release: 8, cutoff: 70
    synth :prophet, note: :e1 + 4, release: 8, cutoff: 80

Laat ons dit nu door het `:slicer`FX leiden:

    with_fx :slicer do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

Hoor hier, hoe de Slicer, het geluid met een een regelmatige tel, lijkt op en aan te zetten.Merk hierbij op dat de `:slicer` het geluid, gegenereerd tussen de `do`/`end` blocks, beïnvloed. Je kan de snelheid waarmee het geluid wordt af- en aangezet bepalen met de `phase:` opt ( duurtijd fase). Zijn standaard instelling is `0.25`, dat is 4 keer per minuut aan de standaard 60 BPM. Dit maken we sneller:

    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

Speel nu zelf met de verschillende `phase:` tijden. Probeer langere en kortere waarden. Zie wat er gebeurt wanneer je kiest voor een heel korte-waarde. Probeer ook verschillende synths zoals `:beep` of `:dsaw` en probeer ook andere noten. Bekijk het volgende diagram om te zien hoe verschillende `phase:` waarden, het aantal veranderingen op de amplitude per beat wijzigt.

De duur van een fase is de lengte van een aan/uit cyclus. Daarom zullen kleinere waarden, de FX schakelaar veel sneller aan-/ uitschakelen, dan grotere waarden. Leuke waarden om mee te beginnen spelen zijn `0.125`, `0.25`, `0.5` en `1`.

## Golfsoort Instellen

Standaard gebruikt het `:slicer` FX een blokgolf om de amplitude in een bepaalde tijdsduur te manipuleren. Daarom horen we amplitude voor een tijdje, en dan voor een tijdje helemaal niet, om dan weer met een zelfde cyclus te beginnen. Het is zo dat de blokgolf één van de vier golfvormen is die we kunnen instellen in deze `:slicer`. De andere golfsoorten zijn: zaagtand, driehoeksgolf, en (co)sinus. Kijk ook eens naar de onderstaande afbeelding om te zien hoe deze eruit zien. We kunnen ook horen hoe deze klinken. De volgende code gebruikt een sinusgolf als controlegolf. Hoor nu dat het geluid niet abrupt aan en uit gaat, maar zacht in- en uit-fade:

    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

Speel met verschillende golftypes door de `wave:` opt naar `0` te veranderen voor saw (zaagtandgolf) , `1` voor square (blokgolf), `2` voor triangle (driehoeksgolf) en `3` voor sine (sinusgolf). Bekijk ook hoe deze verschillende golftypes klinken met verschillende `phase:` opts.

Elk van deze golven kan worden omgekeerd met de `invert_wave:` optie, en spiegelt deze tegenover de Y-as. Bijvoorbeeld, in een enkele fase, zal een zaagtand-golf normaal gezien op zijn hoogste punt beginnen en langzaam naar beneden te gaan, om dan terug naar zin hoogste punt te springen. Met `invert_wave: 1` zal deze nu op het laagste punt beginnen en langzaam naar boven gaan, om dan naar beneden te vallen. Bijkomend, kan je de golf ook instellen dat deze op andere punten start met de `phase_offset:` optie. Deze kan een getal bevatten tussen `0` en`1`. Door te gaan spelen met de `phase:`, `wave:`, `invert_wave:` en`phase_offset` opties kan je de amplitude binnen een tijdsverloop dramatisch veranderen.

## Het instellen van je niveaus

Standaard schakelt `:slicer` tussen de amplitude-waarden `1` (luid) en `0` (stil). Dit kan je veranderen met de `amp_min:` en `amp_max:` opties. Je kan deze gebruiken naast de sinusgolf instelling om een eenvoudige tremolo-effect te bekomen:

    with_fx :slicer, amp_min: 0.25, amp_max: 0.75, wave: 3, phase: 0.25 do
      synth :saw, release: 8
    end

Dit is zoals je de volumeknop van je hi-fi op en neer zou bewegen, zodat het geluid een beetje aan en uit ‘wiebelt’.

## Probabiliteit

Een van de krachtigste functies van ‘: slicer’ , is de mogelijkheid of u de slicer aan of uit wil schakelen. Vooraleer het `:slicer` FX een nieuwe fase start, zal deze een teerling werpen, en gebaseerd op de uitkomst hiervan , de geselecteerde controle golf gebruiken, of de amplitude niet aanzetten. Laten we even gaan luisteren:

    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

Hoor hoe we nu een interessant ritme van pulsen hebben bekomen. Probeer de `probability:` optie naar een andere waarde tussen `0` en `1` te veranderen. Waarden dichter bij `0` zullen meer ruimte tussen elk geluid hebben, doordat de waarschijnlijkheid dat het geluid wordt getriggerd veel lager ligt.

Wat je zeker ook nog moet weten is, dat het probabiliteitssysteem in FX, net zoals het randomisatie-systeem toegankelijk is via functies zoals `rand` en`shuffle`. Ze zijn beide volledig deterministisch. Dit betekent dat elke keer je op afspelen klikt, je precies hetzelfde ritme van pulsen zal horen binnen een bepaalde probabiliteit. Wil je toch nog dingen veranderen, gebruik dan de `seed:` opt om een verschillend start seed te kiezen. Dit werkt precies hetzelfde als `use_random_seed` maar zal enkel invloed hebben op dat bepaalde FX.

Tenslotte kan je ook nog de ‘rust’ positie van de controle-Golf als de probabiliteit-test mislukt, van `0` naar eender welke positie brengen met de `prob_pos:` opt:

    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

## Beats Slicen (Opknippen)

Wat ook heel leuk is om te doen is het gebruik van `:slicer` om een drum beat aan en uit te knipperen:

    with_fx :slicer, phase: 0.125 do
      sample :loop_mika
    end

Hiermee kunnen we met eender welke sample nieuwe ritmische mogelijkheden creëren, heel leuk om mee te spelen. Waar je wel op moet letten is dat het tempo van de sample past in het huidige BPM van Sonic Pi, anders knipt hij naast het ritme. Probeer bijvoorbeeld de `:loop_mika` met de `loop_amen` sample te verwisselen, om te horen hoe slecht dit kan klinken als het tempo niet uitlijnt.

## Tempo Veranderen

Zoals we reeds gezien hebben, als het standaard BPM met `use_bpm` wordt veranderd, zal dit ervoor zorgen dat de rusttijden (sleep) en de enveloppe van de synths gaan groeien of krimpen, om gelijk met de tel te kunnen lopen. De `:slicer` FX houdt hier ook rekening mee, vermits de `phase:` optie in de maat wordt berekend en niet in seconden. We kunnen dus bovenstaand probleem oplossen door de BPM te veranderen om deze met de sample te laten passen:

    use_sample_bpm :loop_amen
    with_fx :slicer, phase: 0.125 do
      sample :loop_amen
    end

## Waardoor het allemaal samen valt

Laten we deze ideeën nu even toepassen in een laatste voorbeeld waar enkel het `:slicer` FX wordt gebruikt om een interessante combinatie te maken. Ga je gang, begin dingen te veranderen en maak er je eigen nummer van!

    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

# - Vijf Live-Coding Technieken

In de Sonic Pi zelfstudie van deze maand gaan we eens kijken hoe je Sonic Pi als een echt muziekinstrument kan gaan hanteren. We moeten daarvoor met een andere blik naar de code beginnen kijken. Live Coders bekijken hun code zoals een violist naar zijn strijkstok kijkt. Zoals een violist in feite verschillende strijktechnieken gebruikt om andere klanken te creëren (lange trage bewegingen of korte snelle aanslagen), zullen wij vijf van de basistechnieken onderzoeken die Sonic Pi mogelijk maakt. Aan het eind van het artikel, kan je je eigen live coding optreden beginnen oefenen.

## 1. Het onthouden van de Sneltoetsen

De eerste tip om met Sonic Pi live coding te gaan doen is beginnen gebruik maken van de sneltoetsen. Bijvoorbeeld, in plaats van kostbare tijd te verliezen door de muis te moeten gaan nemen om op de afspeeltoets te klikken kan je simpelweg tegelijk de `alt` en`r` toets typen, dat werkt niet alleen sneller, je vingers staan zo ook al klaar op het klavier voor de volgende bewerking. Je kan de sneltoetsen voor de belangrijkste knoppen bovenaan makkelijk uitzoeken door met de muis eroverheen te zweven. Zie sectie 10.2 voor de ingebouwde handleiding voor de volledige lijst met sneltoetsen.

Wanneer je een voorstelling doet is het ook prettig om je armbewegingen met wat flair te doen als je een sneltoets aanslaat. Zo is het bijvoorbeeld heel goed met het publiek fysiek te communiceren als je op het punt staat een verandering te maken, dus maak een mooie beweging als je `alt-r` typt, net zoals een gitarist zou doen wanneer hij een power chord aanslaat.

## 2. Handmatig je geluid van lagen voorzien

Nu je de code direct kunt activeren met het computerklavier, kan je deze vaardigheid voor onze tweede techniek gaan gebruiken, en dat is handmatig je geluid van lagen voorzien. In plaats van te componeren door meermaals een `play`, en een `sample` op te roepen, gescheiden door oproepen van `sleep`, hebben we één oproep naar `play` welk we manueel activeren met `alt-r`. Typ de volgende code in een nieuwe buffer:

    synth :tb303, note: :e2 - 0, release: 12, cutoff: 90

Klik nu op de `Afspeel` knop wanneer de klank loopt, verander de code om vier tonen te zakken door het volgende te doen:

    synth :tb303, note: :e2 - 4, release: 12, cutoff: 90

Klik nu terug op `Afspelen`, om beide klanken, tegelijk te horen spelen. Dit komt omdat de `Afspelen`knop van Sonic Pi niet wacht tot een voorgaande code is afgelopen, maar in plaats daarvan de code tegelijkertijd start. Dit betekent dat je makkelijk veel lagen van je geluid van kleinere of grotere veranderingen kan voorzien tussen elke trigger. Verander bijvoorbeeld zowel de `note:` als de `cutoff:` opties en herstart dan.

Je kan deze techniek ook gebruiken met lange abstracte samples. Bijvoorbeeld:

    sample :ambi_lunar_land, rate: 1

Probeer de sample op te starten en dan geleidelijk de `rate:` waarde te halveren tussen de afspeelcommando’s door en gebruik getallen tussen `1` tot `0.5` tot `0.25` tot `0.125` en probeer zelfs negatieve waarden zoals `-0.5`. Voeg lagen toe en kijk waar je uitkomt. Voeg er tenslotte nog een snuifje FX aan toe.

Werken met eenvoudige regels code tijdens een uitvoering, betekent hier dat een publiek dat niet vertrouwd is met Sonic Pi, een goede kans maakt, te begrijpen wat jij aan het doen bent, en de code kunnen koppelen en lezen aan de klank die ze horen.

## 3.Live Loops Masteren

Als je eerder met ritmische muziek werkt, kan het dikwijls moeilijk zijn om alles manueel te activeren en hierin een goeie timing te houden. In plaats daarvan is het dikwijls beter om een `live_loop`te gebruiken. Het geeft herhaling aan je code en geeft je ook de mogelijkheid de code te bewerken voor de volgende cyclus van een loop. Deze lopen samen met andere `live_loop`s, wat betekent dat je deze kan lagen met elkaar en manueel triggers codeert. Bekijk sectie 9.2 van de ingebouwde handleiding om meer over live loops te weten te komen.

Denk eraan om, bij een uitvoering, gebruikt te maken van de `sync:` optie van `live_loop`om te kunnen herstellen van een accidentele doorloop die de live loop stopt door een fout. Als je de `sync:` optie laat verwijzen naar een andere geldige `live_loop`, kan je snel de fout herstellen en de code te herstarten zonder een tel te missen.

## 4. De Master Mixer Gebruiken

Een van Sonic Pi’s best bewaarde geheimen, is dat deze een master mixer heeft, waar het geluid doorgaat. Deze mixer heeft zowel een low pass- als een high pass filter ingebouwd, zodat je makkelijk het globale geluid kan modificeren. De functies van de master mixer is toegankelijk via de fn `set_mixer_control!`. Gebruik bijvoorbeeld het volgende, terwijl je de code loopt en hoort, in een vrije buffer, en druk op `Afspelen`:

`set_mixer_control! lpf: 50`

Nadat je deze code uitvoert, worden alle bestaande en nieuwe geluiden van een low pass filter voorzien en daarom zal het geluid nu meer gedempt zijn. Merk op, dat dit betekent, dat de waarden van nieuwe mixer blijvend zijn, totdat ze weer veranderd worden. Je kan echter, als je wil, altijd opnieuw de mixer terug naar de standaard instelling zetten met `reset_mixer!`. Een aantal van de huidige ondersteunde opts zijn: `pre_amp:`, `lpf:` op hpf:`en` amp:`. Voor de volledige lijst, zie de ingebouwde handleiding voor` set_mixer_control!`.

Gebruik de `*_slide` opts van de mixer om tussen een of meerdere opt waarden te schuiven. Om bijvoorbeeld langzaam de waarde van de mixer’s low pass filter van de huidige waarde naar 30 te brengen, gebruik het volgende:

    set_mixer_control! lpf_slide: 16, lpf: 30

Je kan dan snel terug naar boven schuiven voor een hogere waarde met:

    set_mixer_control! lpf_slide: 1, lpf: 130

Als u optreed is het nuttig om een lege buffer vrij te houden om zoals hier met de mixer te werken.

## 5. Oefening

De meest belangrijke techniek voor live coding is oefening. Het meest gezamenlijke kenmerk van professionele muzikanten is dat ze het bespelen van hun instrumenten - vaak vele uren per dag, oefenen. Oefening is net zo belangrijk voor een live-coder als voor een gitarist. Oefening laten uw vingers bepaalde patronen en veel voorkomende bewerkingen onthouden, zodat je deze kan typen, en je meer vloeiend met hen kan werken . Het oefenen geeft je ook de mogelijkheid nieuwe klanken en constructies te kunnen gaan verkennen .

Bij het uitvoeren, zal je zien dat hoe meer oefening je doet, hoe makkelijker het voor je zal zijn om te ontspannen bij het optreden. Oefening zal je ook een schat aan ervaring geven, om uit te putten. Dit kan je helpen te begrijpen welke soorten wijzigingen interessant zullen zijn en goed werken met de huidige “sound”.

## Waardoor het allemaal samen valt

In plaats van je een laatste Voorbeeld te geven, waarin alle aangeleerde dingen worden gecombineerd, laten we deze maand afscheid nemen door je een uitdaging te laten aangaan. Kijk of je een week lang al deze ideeën kan oefenen. Bijvoorbeeld, de ene dag oefen je alle manuele triggers, de volgende dag wat `live_loop` basiswerk en de volgende dag speel je met de master mixer. Dan herhaal je dit. Maak je geen zorgen dat dit eest met horten en stoten gaat, blijf oefenen en voor je het weet ben je echt voor een publiek aan het live coden.

# - 8 Tips om Live-Coding te oefenen

Vorige maand namen we een kijkje naar vijf belangrijke technieken om live-coding te beheersen - in andere woorden, we onderzocht hoe we gebruik kunnen maken van Sonic Pi en de code te benaderen op eenzelfde manier als een muziekinstrument. Een van de belangrijkste concepten die we besproken hebben, is deze van oefening. Deze maand gaan we hier dieper op in, om te begrijpen waarom het oefenen van live coding zo belangrijk is en hoe je eraan zou kunnen beginnen.

## Regelmatig oefenen

Het belangrijkste advies is om ervoor te zorgen dat je regelmatig oefent. Als regel oefen ik meestal 1-2 uur per dag, maar 20 minuten is prima wanneer je begint. Kleine beetjes maar wel vaak is waar je naar zou willen streven - dus als het je lukt slechts 10 minuten, is al een goede start.

Oefening tip #1 Begin een routine om te oefenen op te bouwen. Bepaal een leuk tijdstip, dat jou het beste uitkomt, om zoveel mogelijk dagen in de week te kunnen oefenen. Het zal niet lang duren eer je naar je dagelijkse sessie uitkijkt.

## Leer blind typen

Als je een professionele muzikant op het podium ziet ,zal je waarschijnlijk een paar dingen merken. Ten eerste, als ze spelen staren ze niet zo overduidelijk op hun instrument. Hun vingers, armen en lichamen weten welke toetsen, snaren te plukken of drums te raken zonder hier veel over na te denken. Dit is bekend als “muscle memory” (spier geheugen) en hoewel dit misschien klinkt als iets dat alleen professionals kunnen doen - het is net hetzelfde als wanneer je voor het eerst geleerd hebt om te lopen of om fiets te rijden- oefenen door middel van herhaling. Live programmeurs gebruiken spier geheugen om niet na te moeten denken over waar hun vingers te zetten, zodat ze zich kunnen concentreren op de muziek. Dit is de zogenaamde touch-typen - typen zonder te kijken naar het toetsenbord.

Oefening tip #2 - leer blind typen. Er zijn vele apps, websites en zelfs games die jou daarbij kunnen helpen. Kies er een die er voor jou goed uitziet en blijf deze gebruiken tot je code kan typen en niet meer hoeft te kijken.

## Codeer terwijl je rechtstaat

Het lichaam van een muzikant is geconditioneerd naar het spelen van hun instrument. Zo moet bijvoorbeeld een trompettist hard kunnen blazen, een gitarist zijn greep krachtig kunnen zijn op het fretboard en een drummer de drums voor langere tijd kunnen slaan. Dus, wat is het fysieke aan live coding? Net als DJs, zullen live coders doorgaans rechtstaan bij een optreden, en sommige zullen zelfs dansen terwijl ze coden! Als je live coden oefent terwijl je zittend achter een bureau zit en dan moet rechtstaan op een optreden, zal je het verschil zeer moeilijk en frustrerend vinden.

Oefening tip #4 - Sta recht als je oefent. De eenvoudigste manier om dit te doen is gebruik te maken van een bureau op stahoogte . Maar als je net zoals ik er thuis geen hebt, zijn er wel een paar low-fi opties. Ik gebruik bijvoorbeeld een strijkplank en dat werkt bijzonder goed voor me. Een andere optie is, wat dozen op elkaar stapelen, of een stapel boeken op een gewone tafel te schikken, en je keyboard hierboven op te zetten. Vergeet niet te stretchen voor je begint en probeer ook een beetje te dansen tijdens de sessie. Denk eraan, niemand kijkt, amuseer je, op het podium zal het later veel meer naturel aanvoelen.

## Oefen het opstellen

De meeste instrumenten vereisen enige montage en moeten gestemd, voordat ze afgespeeld kunnen worden. Tenzij je een rockstar met een bus vol roadies hebt, moet je je eigen instrument voor je optreden klaarmaken. Dit is vaak een stressvol moment en problemen kunnen hier ook makkelijk de kop opsteken. Een manier om dit te verhelpen is het setup-proces in uw oefen sessies in te bouwen.

Oefen tip #4 - Behandel het opstellen als een belangrijk onderdeel van je oefening. Hou je Raspberry Pi en je toetsenbord enz… in een een doos of tas. Pak deze dan voor elke oefening uit en stel ze op en start de computer en Sonic Pi op en je geluid hebt. Als je oefening gedaan is, neem je de tijd om alles weer zorgvuldig in te pakken. In het begin zal dit traag gaan, maar je zal zien, dat je na een tijdje alles snel kan inpakken, zonder hier zelfs maar over na te hoeven denken.

## Experimenteer op muzikaal vlak

Eens je bent opgesteld en klaar om muziek te maken, kan je misschien worstelen met waar te beginnen. Een probleem dat veel mensen hebben is dat ze wel goed weten welke klanken ze willen maken, maar gefrustreerd raken omdat ze niet goed weten hoe ze deze moeten maken. Sommige mensen weten zelfs niet welke klanken te gaan maken! Maak je hier vooral geen zorgen over, dit komt heel vaak voor en het gebeurt bij elke , zelfs doorwinterde muzikant. Het is belangrijker om klanken te maken die je niet mooi vind, dan helemaal niets te maken.

Oefening tip #5 - Besteed tijd aan het maken van klanken en muziek die je niet aanstaan. Maak tijd om nieuwe klanken en ideeën te ondekken. Maak je geen zorgen als het afschuwelijk klinkt en het zelfs de stijl niet is waar je naar zoekt. Door te experimenteren vergroot je de kans om op iets te stuiten op een klank of klankcombinatie die je wel graag hoort! Zelfs als 99% van de geluiden die je maakt slecht zijn, die 1% is misschien de riff of intro van jouw nieuwe track. Vergeet de delen die je niet goed vind en denk aan de delen die je wel mooi vindt. Dat is zelfs makkelijker bij het maken van muziek met code- druk gewoon op bewaren!

## Hoor de code

Veel muzikanten kunnen naar bladmuziek kijken en de muziek in hun hoofd horen, zonder deze te moeten spelen. Dit is een zeer nuttige vaardigheid en het is de moeite waard om deze te integreren in je oefen sessies live-coding.

Oefen tip #6 - Schrijf wat code in Sonic Pi, maar druk niet op afspelen. Probeer je in plaats daarvan, voor te stellen, welke klank deze gaat produceren. Klik dan op Afspelen, luister, en bekijk dan wat je goed had en wat je niet goed had. Herhaal dit tot dit een tweede natuur word tijdens je coding sessies. Als ik oefen heb ik er normaal gezien altijd een goed idee van, hoe de code gaat klinken. Af en toe ben ik echter ook verrast, en besteed ik er even aandacht aan, waarom ik verkeerd was. Elke keer als dit gebeurt, leer ik een nieuw trucje waardoor ik mij op een nieuwe manier kan uiten.

## Verwijder alle afleiding

Een veel voorkomend probleem tijdens het oefenen is dat je makkelijk door andere dingen word afgeleid. Oefenen is moeilijk en vergt een echte discipline, ongeacht het soort muziek dat je maakt - van jazz tot klassiek, EDM. Als je ermee worstelt om aan de slag te gaan of vooruitgang te boeken, is het dikwijls veel makkelijker om even een kijkje te gaan nemen op sociale media of iets op te gaan zoeken op het internet enz… Als je jezelf een oefentijd van 20 minuten voorhoud, is het belangrijk om deze zo productief mogelijk proberen te maken.

Oefen tip #7 - Voor je je oefening begint, doe je zoveel mogelijke afleidingen weg. Zet bijvoorbeeld je wi-fi uit, leg je gsm in een andere kamer, en probeer te oefenen op een rustige plaats, waar je niet gestoord kan worden. Probeer je op het coden van muziek te focussen, je kan later, wanneer je klaar bent, naar je afleidingen terugkeren .

## Hou een oefenboek bij

Wanneer je oefent, zult je vaak merken dat je geest vol zit met spannende nieuwe ideeën - nieuwe muzikale richtingen, nieuwe geluiden om uit te proberen, nieuwe functies om te schrijven, enz. Deze ideeën zijn vaak zo interessant dat je zou willen stoppen met wat je aan het doen bent en begint te werken aan dat idee. Dit is een andere vorm van afleiding!

Oefen tip #8 - Hou een oefendagboek bij naast je keyboard. Wanneer je een gaaf idee krijgt, pauzeer de oefening even en schrijf je idee op, vergeet deze dan en oefen verder. Je kan er dan extra tijd besteden aan je ideeën en deze uitwerken na je oefening.

## Waardoor het allemaal samen valt

Probeer ook zoveel mogelijk routine te krijgen in het oefenen van deze nieuwe ideeën. Probeer de oefensessies zo leuk mogelijk te houden, maar wees er wel van bewust dat sommige sessies zwaar zullen zijn en als hard werken aanvoelen. Het zal het allemaal waard zijn als je je eerste stuk hebt gemaakt en je eerste optreden hebt gegeven. Den eraan, oefening is de sleutel naar succes!

# - Sample Stretching

Wanneer mensen Sonic Pi ontdekken, een van de eerste dingen die ze leren, hoe eenvoudig het is om vooraf opgenomen geluiden af te spelen met behulp van de `sample` functie. Je kan bijvoorbeeld een industriële drumloop afspelen, het geluid van een koor horen of zelfs naar een kras op vinyl luisteren, allemaal via een enkele regel code. Veel mensen beseffen echter niet dat je eigenlijk de snelheid waarmee de sample wordt afgespeeld kan variëren wat voor een krachtige effect kan zorgen en de controle over je opgenomen geluiden naar een nieuw niveau kan tillen . Dus, start een kopie van Sonic Pi en laten ons aan de slag gaan met wat sample stretching!

## Samples vertragen

Om de afspeelsnelheid van de sample te wijzigen moeten we de `rate:` optie gebruiken:

    sample :guit_em9, rate: 1

Als we een `rate:` waarde van `1` toekennen wordt de sample op de normale snelheid afgespeeld. Als we deze op halve snelheid willen afspelen gebruiken we simpelweg een `rate:` van`0.5`:

    sample :guit_em9, rate: 0.5

Merk op dat dit twee gevolgen voor de audio heeft. Ten eerste zullen de samples lager in toonhoogte klinken en ten tweede duurt twee keer zo lang om ze af te spelen (Zie de zijbalk voor de uitleg waarom dit het geval is). We kunnen zelfs nog lager kiezen en lagere snelheden, naar ‘0’ toe, een `rate:` van ‘0,25’ is de kwart snelheid, ‘0.1’ is voor een tiende van de snelheid, enz. Probeer af te spelen met enkele lage snelheden en zie of je het geluid naar een laag gerommel kan omzetten.

## Samples versnellen

Naast het maken van langere, lager klinkende samples door een kleiner waarde voor de snelheid te gebruiken, kunnen we hogere waarde ingeven om kortere en hoger klinkende geluiden te maken. Laten we dit nu even met een drumloop doen. Hoor even hoe dit klinkt met de standaard snelheid van `1`:

    sample :loop_amen, rate: -1

Nu versnellen we deze een beetje:

    sample :loop_amen, rate: 1.5

Ha! Nu verhuisden we naar een ander muzikaal genre, van old-skool techno naar jungle. Merk hierbij op dat zowel elke drumslag hoger klinkt als het gehele ritme versnelt. Probeer nu nog hogere waarden uit en zie hoe hoog en hoe kort je de drumloop kan maken. Als je bijvoorbeeld een snelheid van `100`gebruikt, verandert de drumloop naar een enkele klik!

## In achteruit versnelling

Ik weet zeker dat velen nu gaan denken… “wat als we nu eens een negatieve waarde gebruiken voor de `rate:`?” Goeie vraag! Als `1`de normale snelheid is en ´2´dubbele snelheid en waarbij `0,5` de halve snelheid is, dan moet `-1`achterwaarts zijn! Laten we dit met een snare uitproberen. Laten we deze eerst op normale snelheid afspelen:

    sample :elec_filt_snare, rate: 1

Cool! Het speelt achterstevoren:

    sample :elec_filt_snare, rate: -1

Natuurlijk kan je ook achterwaarts dubbel zo snel met een waarde van `-2` of achterwaarts op halve snelheid met `-0,5`. Speel nu even met verschillende negatieve waarden en amuseer je hiermee. Het is bijzonder grappig met de `:misc_burp` sample!

## Sample, Rate and Pitch [Sidebar]

Een van de effecten van het modificeren van de snelheid van samples, is dat bij hogere snelheden de klank hoger klinkt en bij trage snelheid lager. In het alledaagse leven hebt je misschien ook al eens opgemerkt dat wanneer een ziekenwagen voorbij rijd, als deze aankmt gereden zal de sirene hoger klinken dan wanneer deze voorbij is gereden- het zogenaamde Doppler effect. Waarom gebeurd dit?

Laten we even een simpele biep nemen die wordt vertegenwoordigd door een sinusgolf. Als we een oscilloscoop gebruiken om de grafische weergave van deze biep te kunnen zien krijgen we zoiets als Figuur B en bij een octaaf lager zien we zoiets als Figuur C. Merk op dat de golven van hogere noten compacter zijn en dat de golven van lagere noten meer uitgespreid zijn.

Een sample van een pieptoon is niets meer dan een heleboel cijfers (x, y, coördinaten) die wanneer ze uitgezet worden op een grafiek hun oorspronkelijke curven laten zien. Zie figuur D waarbij elke cirkel een coördinaat vertegenwoordigd. Om de coördinaten terug om te zetten in geluid, zet de computer elke x-waarde en de bijbehorende waarde van y naar de luidsprekers om. De truc hier is dat de afspeelsnelheid waarmee de computer zich door de x-nummers werkt niet dezelfde moet zijn als de snelheid waarmee zij werden geregistreerd. Met andere woorden, kan de ruimte (die de tijd vertegenwoordigen) tussen elke cirkel worden uitgerekt of samengedrukt. Dus, als de computer de x-waarden sneller dan het oorspronkelijke snelheid doorloopt, zal het het effect van het samendrukken van de cirkels in een hogere klinkende pieptoon resulteren. Het maakt ook de pieptoon korter maken gezien we sneller door de cirkels lopen. Dit wordt getoond in figuur E.

Tot slot, interessant om weten is dat, een wiskundige genaamd Fourier bewees dat elk geluid eigenlijk bestaat uit heel veel sinusgolven. Daarom, als we een opgenomen geluid comprimeren , rekken we vele sinusgolven allemaal op hetzelfde moment op precies deze manier uit.

## Pitch Bending

Zoals we hebben gezien, zal met een sneller tempo het geluid hoger in toonhoogte, en een trager tempo zal het geluid lager in toonhoogte zijn. Een zeer eenvoudige en nuttige truc is om te weten dat een verdubbeling van de rate waarde, eigenlijk resulteert in een toonhoogte van een octaaf hoger wordt en omgekeerd de halvering van de rate waarde resulteren in een toonhoogte van een octaaf lager. Dit betekent dat voor melodische samples, het naast elkaar afspelen op het dubbel/helft van de rate waarde, deze eigenlijk vrij mooi klinken:

    sample :bass_trance_c, rate: 1
    sample :bass_trance_c, rate: 2
    sample :bass_trance_c, rate: 0.5

Maar, wat als we gewoon het tempo willen veranderen zodat de toonhoogte stijgt met een halve toon (één noot hoger op een piano)? Sonic Pi maakt dit zeer eenvoudig via de ‘ rpitch:’ optie:

    sample :bass_trance_c
    sample :bass_trance_c, rpitch: 3
    sample :bass_trance_c, rpitch: 7

Als je een kijkje neemt op het log aan de rechterkant, zal je merken dat een ‘ rpitch:’ van ‘3’ overeenkomt met een snelheid van ‘1.1892’ en een ‘ rpitch:’ van ‘7’ overeenkomt met een snelheid van ‘1.4983’. Tot slot kunnen we zelfs de ‘ rate:’ en ‘ rpitch:’ optie combineren:

    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

## Waardoor het allemaal samen valt

Laat ons even kijken naar een eenvoudig stukje waarbij deze ideeën gecombineerd worden . Kopieer deze naar een lege Sonic Pi buffer en klik op afspelen, luister even en gebruik deze dan als uitgangspunt voor je eigen stuk muziek. Merk hoe leuk het is om de snelheid van het afspelen van samples te manipuleren. Als extra oefening probeer je je eigen geluiden op te nemen en speel met de rate waarden om te zien wat voor gekke geluiden je hiermee kan maken.

    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

# - Additieve Synthese

Dit is de eerste van een reeks korte artikeltjes over het gebruik van Sonic Pi bij klankontwerp (Sounddesign). We nemen een rondleiding door een aantal technieken die voor je beschikbaar zijn om je eigen unieke klank te ontwikkelen. De eerste techniek die we zullen bekijken heet * additieve synthese *. Dit kan ingewikkeld klinken - maar als we elk woord even apart bekijken is de betekenis vrij snel duidelijk. Ten eerste, additief betekent letterlijk de combinatie van een aantal elementen en het tweede woord synthese, betekent geluid creëren . Additieve synthese betekent daarom niets minder dan * bestaande geluiden combineren om nieuwe te maken *. Deze synthese techniek dateert al van lang geleden - bijvoorbeeld pijporgels in de middeleeuwen hadden veel lichtjes verschillende cillinderpijpen die je met tussenpozen kan in- of uitschakelen. De stop uit een bepaalde pijp trekken ‘voegt deze aan de mix toe’ en maakt het geluid rijker en complexer. Nu, laten we eens kijken hoe we dat kunnen doen met Sonic Pi.

## Eenvoudige combinaties

Laten we beginnen met het meest elementaire geluid dat er is - de eenvoudige zuiver gestemde sinus golf:

    synth :sine, note: :d3

Laten we eens kijken hoe dit klinkt gecombineerd met een blokgolf:

    synth :sine, note: :d3
    synth :square, note: :d3

Merk op hoe deze twee geluiden combineren tot een nieuwe, rijker geluid. Natuurlijk, hoeven we hier nog niet te stoppen, we kunnen zoveel geluiden we willen toevoegen. We moeten echter wel voorzichtig zijn hoe veel geluiden we bij elkaar gaan optellen. Net zoals wanneer we verf maken om nieuwe kleuren te mengen, het toevoegen van dat beetje teveel kleur zal resulteren in bijvoorbeeld een rommelig bruin, evenzo - zal het toevoegen van te veel geluiden resulteren in een modderig geluid.

## Mengen

Laten we iets toevoegen om het geluid een beetje helderder te maken. We zouden een driehoeksgolf kunnen gebruiken van een octaaf hoger (voor dat hoge heldere geluid) voorlopig op amp ‘0.4’ afgesteld om iets extra’s toe te voegen aan het geluid, zo dat dit geluid het niet overheerst:

    synth :sine, note: :d3
    synth :square, note: :d3
    synth :tri, note: :d4, amp: 0.4

Nu, probeer je eigen geluid te creëren door een combinatie van 2 of meer synths op verschillende octaven en amplitudes. Merk ook op dat je met elke synth kunt spelen en elk brongeluid afzonderlijk kan worden gewijzigd voordat het wordt gemengd in nog meer combinaties van geluiden.

## Detuning (Ontstemmen)

Tot nu toe hebben we bij het combineren van onze verschillende synthesizers dezelfde toonhoogte gebruikt of zijn we naar een andere octave overgestapt. Hoe zou het misschien klinken als wij ons niet aan octaven vasthouden, maar in plaats daarvan voor een iets hogere of lagere noot zouden kiezen? Laten we dit proberen:

    detune = 0.7
    synth :square, note: :e3
    synth :square, note: :e3 + detune

Als we onze blokgolf met een 0.7 noot ontstemmen, klinkt dit misschien vals of niet in harmonie. Hoe dichter bij de 0 plaats je het geluid minder uit toon gezien de toon van de golven meer en meer met elkaar gaan samenvallen. Probeer dit zelf maar eens uit! Verander de waarde van de `detune:` opt van `0.7` naar `0.5`en luister hoe het geluid hierbij veranderen kan. Merk op dat lage ontstemde noten zoals bij `0.1`een heel fijn ‘vet’ geluid produceren en waarbij de lichtjes verschillende toonhoogten op een interessante wijze met elkaar een wisselwerking aangaan, dikwijls op zeer verrassende wijze .

Sommige van de ingebouwde synths beschikken reeds over een detune optie die exact dit toepast in één synth. Probeer te spelen met de ‘ detune: ‘ opt van ‘: dsaw ‘,’: dpulse’ en ‘: dtri’.

## Amplitude vormgeven

We kunnen ons geluid ook nog op een andere manier bijschaven door voor elke synth een andere envelope te gebruiken. Deze laten jou toe om sommige elementen van het geluid percussief te laten klinken terwijl we andere elementen langer kunnen laten naklinken.

    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

In het bovenstaande voorbeeld heb ik lawaaierige percussieve elementen gemixt met een meer aanhoudend achtergrond gerommel. Dit werd bereikt door twee noise synth’s met een middelmatige cutoff waarde (`90`en `100`) door gebruik te maken van korte release-tijd waarden, samen met een ruis die een langere release-tijd heeft, met een lagere cutoff waarde (om het geluid minder scherp en meer rommelend te maken.)

## Waardoor het allemaal samen valt

Laten we deze technieken combineren om te zien of we gebruik kunnen maken van additieve synthese om een elementair bel geluid te re-creëren . Ik heb dit voorbeeld opgedeeld in vier secties. Als eerste hebben we het ‘aanslag’-gedeelte, die het begin uitmaakt van onze bel klank - en dus gebruik maakt van een korte envelop (bijv. een `release:` van rondom `0.1`). Vervolgens hebben we het lange ring gedeelte waarin ik het pure geluid van de sinusgolf gebruik . Merk op dat ik vaak het verhogen van een noot toepas, met ongeveer `12` en `24`, dat het aantal noten met één a twee octaven verhoogd. Ik heb er ook een paar lage sinus golven aan toegevoegd die het geluid wat bas en diepte geeft. Tot slot, gebruik ik `define` om mijn code in een functie te wikkelen, die ik dan kan gebruiken om een melodie af te spelen. Probeer je eigen melodie uit en speel ook met de inhoud van de `:bell` functie totdat je je eigen leuk geluid hebt om mee te spelen!

    Speel een melodie met onze nieuwe klok!

# - Subtractieve synthese

Dit is het tweede in een serie artikelen over het gebruik van Sonic Pi in sound design. Vorige maand hebben we gekeken naar additieve synthese waar we met eenvoudige handelingen, met het tegelijkertijd afspelen van meerdere geluiden, kunnen zorgen voor een nieuw gecombineerde geluid. We kunnen bijvoorbeeld verschillend klinkende synths of zelfs dezelfde synth op verschillende toonhoogten gebruiken om een nieuw complex geluid op te bouwen met eenvoudige ingrediënten. Deze maand nemen we een kijkje naar een nieuwe techniek die in de volksmond subtractieve synthese wordt genoemd, wat gewoon het nemen van een bestaand complex geluid is en deze ontdoen van bepaalde onderdelen, om er iets nieuws van te maken . Dit is een techniek die meestal wordt geassocieerd met het geluid van analoge synthesizers uit de jaren 1960 en 1970, maar ook bekend is door de recente opleving van modulaire analoge synths via populaire nieuwe standaarden zoals bijvoorbeeld Eurorack.

Ondanks dat dit klinkt als een bijzonder ingewikkelde en geavanceerde techniek, maakt Sonic Pi het je verrassend simpel en eenvoudig, we beginnen er gelijk mee.

## Complex Bron Signaal

Om een geluid goed met subtractieve synthese te laten werken, moet deze meestal vrij rijk en interessant op zich klinken. Dat betekent niet dat deze ongelofelijk complex hoeft te zijn, in feite zullen een typische `:square` of`:saw`golf volstaan:

    synth :saw, note: :e2, release: 4

Merk hier op dat dit geluid al vrij interessant is en veel verschillende frequenties boven `:e2` (de tweede E op een piano) bevat, die aan toevoeging doen aan het maken van de klankkleur. Als dat nog niet veel duidelijk maakt, probeer dit te vergelijken met de `:beep`toon:

    synth :beep, note: :e2, release: 4

Vermits de `:beep` synth een eenvoudige sinusgolf is, zal je een meer zuivere toon horen op `:e2` en geen van de meer knapperige/zoemende geluiden die je met `:saw`hoorde. Het is dit bezige, variërende geluid van de sinus golf, die we kunnen gaan gebruiken voor subtractieve synthese.

## Filters

Eens we ons eerste rauwe geluid hebben gevonden, is onze volgende stap deze door een filter te sturen, die delen van het geluid wegneemt of vermindert. Een van de meest gebruikte filters bij subtractieve synthese is de zogenaamde low pass filter. Deze laat alle lage tonen van het geluid door, maar zal de hogere frequenties reduceren of weglaten. Sonic Pi heeft een krachtig maar makkelijk te gebruiken FX systeem waar een low pass filter inzit, namelijk de `:lpf`. Laten we hiermee even spelen:

    with_fx :lpf, cutoff: 100 do
      synth :saw, note: :e2, release: 4
    end

Als je goed luistert zal je horen dat wat geroezemoes en knapperigheid verwijderd is. In feite zijn alle frequenties in het geluid boven `100`gereduceerd of weggenomen en zijn enkel de frequenties daaronder aanwezig in het geluid. Probeer een `cutoff:` te vinden om noten te verlagen met bijvoorbeeld `70` en dan naar `50` en vergelijk dan deze klank.

Uiteraard is de `:lpf` niet de enige filter die je kan gebruiken om een inkomend signaal te bewerken. Een andere belangrijke FX is de high pass filter aangeduid als `:hpf` in Sonic Pi. Dit doet het tegenovergestelde van`:lpf` waar die de hoge delen van het geluid doorlaat en/of afsnijdt, doet deze dat voor de lage delen.

    with_fx :hpf, cutoff: 90 do
      synth :saw, note: :e2, release: 4
    end

Merk op dat het geluid nu drukker en rasperig is nu alle lage frequenties weggenomen zijn. Speel maar even met de cutoff waarden en merk op dat lagere waarden meer van de originele basstonen doorlaten en bij hogere waarden, het geluid dunner en stiller wordt.

## Low Pass Filter

Het low-pass filter is zo’n belangrijk onderdeel in elke gereedschapskist van de subtractieve synthese, dat het moeite waard is iets dieper in te gaan op hoe het werkt. Dit diagram toont dezelfde geluidsgolf (de ‘: prophet ‘ synth) met verscheidene filter hoeveelheden . Aan de top toont deel A de audiogolf zonder filtering. Merk op hoe de golfvorm erg puntig is en veel scherpe randen bevat. Het zijn deze harde, scherpe hoeken die de hoge scherpe delen van het geluid produceren. Sectie B toont het low-pass filter in actie - merk hoe deze minder puntige en meer afgerond heeft, dan de golfvorm hierboven. Dit betekent dat het geluid minder hoge frequenties heeft, waardoor het een meer zacht afgerond aanvoelt . Sectie C toont de low-pass filter met een vrij lage grenswaarde - dit betekent dat zelfs nog meer van de hoge frequenties zijn verwijderd uit het signaal wat resulteert in een nog zachtere, ronder golfvorm. Tot slot merk je hoe de vorm van de golf, die de amplitude vertegenwoordigt, afneemt als we van A naar C gaan. Subtractieve synthese werkt door het verwijderen van delen van het signaal en betekent dus dat de totale amplitude wordt verminderd door de waarde van de filter die verhoogt.

## Filter Modulatie

Tot nu toe klonk ons geluid vrij statisch. Met andere woorden, het geluid verandert op geen enkele manier gedurende zijn gehele duurtijd. Vaak zal je wat beweging in je geluid willen, om wat leven in het timbre te brengen. Een van de manieren om dit te bewerkstelligen is met filtermodulatie, d.w.z. het veranderen van de filter opties gedurende een bepaalde tijd. Sonic Pi heeft gelukkig een krachtig instrument om de FX opt’s, tijdsgebonden te manipuleren. Je kan bijvoorbeeld voor elke moduleerbare opt een bepaalde tijd opgeven, hoe traag of hoe snel deze van een bepaalde waarde, naar de vooropgestelde waarde verschuift:

    with_fx :lpf, cutoff: 50 do |fx|
      control fx, cutoff_slide: 3, cutoff: 130
      synth :prophet, note: :e2, sustain: 3.5
    end

Laat ons even kijken naar wat hier gebeurt. Eerst starten we een `:lpf` FX blok met een initiële `cutoff:` zeer laag op`20`. De eerste regel heeft evenwel een mysterieuze `|fx|` op het einde. Dit is een optioneel onderdeel van de `with_fx` syntax wat ons in staat stelt om een naam te geven aan de lopende FX synth, en deze te manipuleren. Dat is precies wat regel 2 doet, namelijk de `cutoff_slide:` opt naar 4 zetten, en de uiteindelijke `cutoff:` naar `130` te brengen. Het FX zal de `cutoff:` opt’s waarde van `50` naar `130` schuiven, over een periode van 3 tellen. Ten slotte triggeren we een synth, die als bron door deze low pass filter wordt gestuurd.

## Waardoor het allemaal samen valt

Dit is slechts een zeer basic voorproefje van wat mogelijk is als je filters gebruikt om een geluidsbron te wijzigen. Probeer in Sonic Pi met de vele ingebouwde FX te spelen, om te zien wat een gekke geluiden je hiermee kan ontwerpen. Als je geluid te statisch aanvoelt , vergeet niet dat je de opties kan moduleren om bewegingen aan te brengen.

Laten we eindigen, met het ontwerpen van een functie die een nieuw geluid maakt met subtractieve synthese. Zie of je kan achterhalen wat hier aan de hand is - en voor de gevorderde Sonic Pi lezers: - kijk of je kunt vinden waarom ik alles in de oproep verpak naar `at` (stuur de antwoorden naar @samaaron op 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

# - Creative coding in the classroom with Sonic Pi

(This article was published in issue 9 of the Hello World Magazine)

Code is one of the most creative media that humans have created. The initially obscure symbols of parentheses and lambdas are not just deeply rooted in science and mathematics, they are the closest we have managed to get to casting the same kind of magical spells as Gandalf and Harry Potter. I believe that this provides a powerful means of engagement in our learning spaces. Through the magic of code we are able to conjure up individually meaningful stories and learning experiences.

We are surrounded by magical experiences. From the sleight of hand of a stage magician making the ball disappear into thin air, to the wonder of seeing your favourite band perform on a big stage. It is these “wow” moments that inspire us to pick up a magic book and learn the French Drop or to start jamming power chords on an old guitar. How might we create similarly deep and lasting senses of wonder that will motivate people to practice and learn the fundamentals of programming?

## Musical Engines and Notation

The histories of music and computers have been intricately woven together since the inception of computing machines, or “engines” as Charles Babbage’s powerful analytical engine was called. Back in 1842 the Mathematician Ada Lovelace, who worked very closely with Babbage, saw the creative potential of these engines. Whilst these first engines had originally been designed to accurately solve hard maths problems, Ada dreamt about making music with them:

”..the engine might compose elaborate and scientific pieces of music of any degree of complexity or extent.” Ada Lovelace, 1842.

Of course, today in 2019 much of our music, regardless of genre, has either been composed, produced or mastered with a digital computer. Ada’s dream came true. It is even possible to trace the history back even further. If you see coding as the art of writing sequences of special symbols that instruct a computer to do specific things, then musical composition is a very similar practice. In Western music, the symbols are black dots positioned on a stave of lines that tell the musician which notes to play and when. Intriguingly, if we trace the roots of Western music notation back to the Italian Benedictine monk, Guido d’Arezzo, we find that the dots and lines system that modern orchestras use is just one of a number of notation systems he worked on. Some of the others were much closer to what we might now see as code.

Get

## Sonic Pi Performances

Live Coderen

Sonic Pi has been used to perform in a wide range of venues such as school halls, nightclubs, outdoor stages at musical festivals, college chapels and prestigious music venues. For example the amazing Convo project which brought 1000 children together in the Royal Albert Hall to perform an ambitious new composition by composer Charlotte Harding. The piece was written for traditional instruments, choirs, percussion and Sonic Pi code. The pop-artist Jylda also performed with Sonic Pi in the Sage Gateshead for the Thinking Digital Conference, where she created a unique live-coded improvised remix of her song Reeled.

Sonic Pi used as one of the instruments as part of Convo at the Royal Albert Hall. Photo credit: Pete Jones.

## Live coding in the classroom

Sonic Pi is a code-based music creation and performance tool that builds on all of these ideas. Unlike the majority of computing education software, it is both simple enough to use for education and also powerful enough for professionals. It has been used to perform in international music festivals, used to compose in a range of styles from classical, EDM and heavy metal, and was even reviewed in the Rolling Stone magazine. It has a diverse community of over 1.5 million live coders with a variety of backgrounds all learning and sharing their ideas and thoughts through the medium of code. It is free to download for Mac, PC and Raspberry Pi and includes a friendly tutorial that assumes you know nothing about either code or music.

Sonic Pi was initially conceived as a response to the UK’s newly released Computing curriculum in 2014. The goal was to find a motivating and fun way to teach the fundamentals of programming. It turns out that there is a lot in common and it’s huge fun to explain sequencing as melody, iteration as rhythm, conditionals as musical variety. I developed the initial designs and first iterations of the platform with Carrie Anne Philbin, who brought a teacher’s perspective to the project. Since then, Sonic Pi has undergone iterative improvements thanks to the feedback gained from observing learners and collaborating directly with educators in the classroom. A core design philosophy was to never add a feature that couldn’t be easily taught to a 10 year old child. This meant that most ideas had to be heavily refined and reworked until they were simple enough. Making things simple whilst keeping them powerful continues to be the hardest part of the project.

In order to provide the magical motivation, Sonic Pi’s design was never limited to a pure focus on education. Ideally there would be famous musicians and performers using Sonic Pi as a standard instrument alongside guitars, drums, vocals, synths, violins, etc. These performers would then act as motivational role models demonstrating the creative potential of code. For this to be possible sufficient focus and effort therefore had to be placed on making it a powerful instrument whilst still keeping it simple enough for 10 year olds to pick up. In addition to educators, I also worked directly with a variety of different artists in classrooms, art galleries, studios and venues in the early stages of Sonic Pi’s development. This provided essential feedback which enabled Sonic Pi to grow and ultimately flourish as a tool for creative expression.

There were a number of exciting and unexpected side effects of this dual focus on education and professional musicians. Many of the features are beneficial to both groups. For example, a lot of effort has been put into making error messages more friendly and useful (rather than being a huge complicated mess of jargon). This turns out to be very useful when you write a bug while performing in front of thousands of people. Additionally, functionality such as playing studio quality audio samples, adding audio effects, providing access to live audio from the microphone all turn out to make the learning experience more fun, rewarding and ultimately meaningful.

The Sonic Pi community continues to grow and share amazing code compositions, lesson plans, musical algorithms, and much more. Much of this happens on our friendly forum in_thread (in-thread.sonic-pi.net) which is home to a very diverse group of people that includes educators, musicians, programmers, artists and makers. It is a real joy to see people learn to use code to express themselves in new ways and for that in turn to inspire others to do the same.

# - Some fun capabilities

From a Computer Science perspective, Sonic Pi provides you with the building blocks to teach you the basics as found in the UK’s curriculum such as sequencing, iteration, conditionals, functions, data structures, algorithms, etc. However, it also builds on a number of important and relevant concepts which have become adopted in mainstream industry such as concurrency, events, pattern matching, distributed computing and determinism - all whilst keeping things simple enough to explain to a 10 year old child.

Get

    play 70

A melody can be constructed with one more command, sleep:

    lay 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

In this example, we play the note 70 (roughly the 70th note on a piano), wait for 1 second, play note 72, wait for half a second and then play note 75. What’s interesting here is that with just two commands we have access to pretty much all of Western notation (which notes to play and when) and learners can code any melody they’ve ever heard. This leads to huge variety in expressive outcomes whilst focussing on the same computing concept: sequencing in this case.

Taking ideas from the professional music world, we can also play back any recorded sound. Sonic Pi can play any audio file on your computer but also has a number of sounds built-in to make things easy to get started:

    sample :loop_amen

This code will play back the drum break which was a pillarstone to early hip-hop, Drum and Bass and Jungle. For example, a number of early hip-hop artists played this drum break back at half speed to give it a more laid-back feeling:

    sample :loop_amen, rate: 0.5

In the 90s a number of music scenes burst out of new technology which enabled artists to take drum breaks like this apart and reassemble in a different order. For example:

    sample :loop_amen

rand

# - Essentiële Kennis

Deze sectie gaat over nuttige - in feite essentiële - kennis om het meeste uit Sonic Pi te halen.

We gaan het hebben over, hoe profijt te halen uit de vele beschikbare sneltoetsen, hoe jouw werk te delen en wat tips hoe met Sonic Pi op te treden.

# - Sneltoetsen gebruiken

Sonic Pi is evengoed een instrument als een coderingsomgeving. Sneltoetsen kunen daarom het bespelen van Sonic Pi efficienter en natuurijker maken- zeker als je live voor publijk speelt.

Veel van Sonic Pi kan worden bestuurd via het toetsenbord. Als je meer vertrouwd raakt met Sonic Pi, zult je de sneltoetsen waarschijnlijk meer en meer beginnen gebruiken. Ik persoonlijk touch-type (ik adviseer je te overwegen om dit te leren) ik vind het frustrerend wanneer ik het nodig vind de muis te gebruiken. Ik gebruik deze shortcuts dus zeer regelmatig!

Daarom, als je de shortcuts leert, leer je je toetsenbord efficienter te gebruiken en je zal in geen tijd live coderen als een pro.

Maar probeer ze niet allemaal tegelijkertijd uit te proberen te leren, enkel die je het meest gebruikt en ze langzaam meer en meer in de praktijk toe te voegen.

## Samenhang tussen Platforms

Stel dat je een klarinet leert bespelen. Je verwachten dan toch dat alle klarinetten van de verschillende merken vergelijkbare controles en vingergrepen zouden hebben. Als dat niet zo was, zou je een moeilijke tijd hebben om tussen de verschillende klarinetten te kunnen schakelen en je zou vasthangen aan het gebruik van slechts één merk.

Helaas zijn de drie belangrijkste besturingssystemen (Linux, Mac OS X en Windows) zijn voorzien van hun eigen standaardwaarden voor acties zoals het knippen en plakken enz. Sonic Pi zal proberen deze normen te respecteren. Deze is echter de prioriteit is geplaatst op de consistentie tussen de platformen binnen Sonic Pi, in plaats te proberen om te voldoen aan de norm van een bepaald platform. Dit betekent dat als je Sonic pi’s shortcuts leert spelen op je Raspberry Pi, je naar Mac of PC kan overschakelen en je thuis voelen.

## Controle en Meta

Het concept van consistentie zit ook in de benaming van de shortcuts. In Sonic Pi gebruiken we de namen Control en Meta om te verwijzen naar de twee belangrijkste combinatie toetsen. Bij alle platformen is Control hetzelfde.Maar op Linux en Windows is Meta eigenlijk de Alt toets is, terwijl Meta op Mac de Command toets is. Voor de samenhang zullen we de term Meta gebruiken - vergeet dit niet naar je besturingsysteem over te zetten.

## Afkortingen

Om de zaken eenvoudig en leesbaar te houden, gebruiken we de afkorting C- voor Control plus andere toets en M- voor Meta plus andere toets. Een voorbeeld: als je bij een shortcut zowel Meta als r moet indrukken schrijven we dit als `M-r`. En de - betekent dan “tegelijk.”

Enkele van de sneltoetsen die ik het meest nuttig vind.

## Stoppen en starten

In plaats van altijd de muis te gebruiken je code te gaan uit voeren, kan je simpelweg op `M-r` drukken. Om het uitvoeren van je code te stoppen kan je `M-s` gebruiken.

## Navigatie

Zonder de navigatie sneltoetsen ben ik echt verloren. Daarom adviseer ik je hieraan wat tijd te besteden. Deze sneltoetsen werken ook extreem goed wanneer je blind hebt leren typen vermits zij ook gebruik maken van de standaard letters in plaats van waarvoor u uw hand naar de muis of naar de pijltoetsen op uw toetsenbord moet gaan bewegen.

Je kan naar het begin van een lijn gaan met`C-a`, naar het einde van de lijn met `C-e`, een lijn omhoog met `C-p`, een lijn naar beneden met `C-n`, een karakter naar voor met `C-f, een karakter teruggaan is` C-b`. Je kan zelfs alle karakters wissen vanaf de cursor tot het einde van de zin met` C-k`.

## Nette Code

Voor het automatisch uitlijnen van jouw code druk `M-m`.

## Help-systeem

Om het help-systeem in te schakelen kan je `M-i` indrukken. Een nog veel nuttiger sneltoets om te kennen is `C-i`die het woor dat zich onder de cursor bevindt opzoekt en alle docs die hierover gevonden wordt zal tonen. Instant hulp!

Voor een volledige lijst kijk je naar punt 10.2 Shortcut Cheatsheet.

# - Shortcut Cheatsheet

Het volgende is een samenvatting van de belangrijkste sneltoetsen die beschikbaar zijn in Sonic Pi. Zie sectie 10.1 voor motivatie en achtergrond.

## Conventies

In deze lijst, gebruiken we de volgende conventies (waar Meta staat is dit Alt op Windows/Linux en Cmd op Mac):

`C-a` betekend hou de Control toets en de a toets tegelijkertijd in, laat dan los. `M-r`betekent hou de Meta toets en druk dan de r toets tegelijkertijd in, laat dan los. `S-M-z` betekent hou de Shift toets, dan de Meta toets, en tenslotte de z toets tegelijkertijd allemaal in en laat dan los. `C-M-f` betekent hou de Control toets, dan de Meta en tenslotte de f toets allemaal tegelijkertijd in, en dan los deze dan.

## Belangrijkste Applicatie Manipulatie

`M-r` - code afspelen `M-s` - Stop code `M-i` - Help Systeem Schakelaar `M-p` - Voorkeursinstellingen Aan/Uit `M-{` - Buffer naar links omwisselen `M-}` - Buffer naar links omwisselen `M-+` - Vergroot de tekstgrootte van de huidige buffer `M--` - Verkleint de tekstgrootte van de huidige buffer

## Selectie/Kopiëren/Plakken

`M-a` - Selecteer alles `M-c` - kopieer selectie om buffer te plakken `M-]` - Kopieer selectie om buffer te plakken `M-x` - Knip selectie om buffer te plakken `C-]` - Knip selectie om buffer te plakken `C-k` - Knip tot het einde van de lijn `M-v` - Plak naar editor vanaf plak buffer `C-y` - Plak naar editor vanaf plak buffer `C-SPACE` - Zet markering. Navigatie zal nu gemarkeerd gebied manipuleren. Gebruik `C-g` om te verlaten.

## Bewerken van tekst

`M-m` - Alle tekst uitlijnen `Tab` - Huidige lijn uitlijnen of selectie (of selecteer automatisch aanvullen) `C-l` - Editor Centreren `M-/` - Comment/Uncomment huidige lijn of selectie `C-t` - Karakters omzetten/ruilen `M-u` - Volgende woord (of selectie) omzetten in hoofdletters. `M-l` - -Volgende woord (of selectie) omzetten in kleine letters.

## Navigatie

`C-a` - Naar het begin van de lijn `C-e` -Verplaats naar einde van regel `C-p` -Verplaatsen naar vorige regel `C-n` - Verplaatsen naar volgende regel `C-f` -Eén teken naar rechts verplaatsen `C-b` - Eén teken naar achter verplaatsen `M-f` - Eén woord naar voor springen `M-b` - Eén woord naar achter springen `C-M-n` -Zet lijn of selectie naar beneden `C-M-p` - Zet lijn of selectie naar boven `S-M-u` - 10 lijnen naar boven gaan `S-M-d` - 10 lijnen naar beneden gaan `M-<` - Naar het begin van de buffer gaan `M->` - Naar het eind van de buffer gaan

## Verwijdering

`C-h` - Vorige teken verwijderen `C-d` - Volgend teken verwijderen

## Geavanceerde Editor Functies

`C-i` - Toon docs voor het woord onder de cursor `M-z` - Ongedaan maken `S-M-z` - Opnieuw maken `C-g` - Verlaten `S-M-f` - Tussen Fullscreen modus schakelen `S-M-b`- Zichtbaarheid van knoppen in-/uitschakelen `S-M-l` - Zichtbaarheid van log in-/uitschakelen `S-M-m` - Tussen licht/donker modus schakelen `S-M-s` - Inhoud van de buffer als een bestand opslaan `S-M-o` - Inhoud van buffer vanuit een bestand laden

# - Delen

Sonic Pi gaat helemaal over het delen en leren met elkaar.

Zodra je geleerd hebt hoe je muziek codeert, is het delen van uw composities zo eenvoudig als het verzenden van een e-mail met jouw code.Deel alsjeblief je code met anderen zodat zij kunnen leren van jouw werk en misschien onderdelen te gebruiken in een nieuwe mash-up.

Als u niet zeker bent van de manier om je werk met anderen te delen, adviseer ik om je code op [GitHub] (https://github.com) en uw muziek op [SoundCloud] (https://soundcloud.com) te zetten. Op die manier kun je gemakkelijk een groot publiek bereiken .

## Code -> GitHub

[GitHub] (https://github.com) is een site om met codete werken en deze te delen. Het wordt gebruikt door professionele ontwikkelaars, maar ook artiesten delen en werken samen aan code. De eenvoudigste manier om een nieuw stuk code te delen (zelfs een onvoltooide stukje) is het creëren van een [Gist] (https://gist.github.com). Een [Gist] (https://gist.github.com) is een eenvoudige manier om uw code te uploaden van op een zodat anderen deze kunnen zien, kopiëren en delen.

## Audio -> SoundCloud

Een andere belangrijke manier om je werk te delen is de audio opnemen en te uploaden naar [SoundCloud] (https://soundcloud.com). Zodra je je stuk geüpload hebt, kunnen andere gebruikers commentaar geven en je werk bespreken . Ik adviseer ook een link te plaatsen van naar een [Gist] (https://gist.github.com) met uw code en daarbij de beschrijving van deze track.

Om je werk op te nemen, sla de`Opname` toets aan in de gereedschapsbalk, en de opname start onmiddellijk. Klik op `Afspelen` om de code te starten als deze nog niet bezig mocht zijn. Als je klaar bent, druk je opnieuw op de knipperende `Opname` knop, en dan kan je een bestandsnaam kiezen. De opname wordt opgeslagen als een WAV-bestand, dat kan worden bewerkt en geconverteerd naar MP3 met eender welk gratis programma (probeer Audacity bijvoorbeeld).

## Hoop

Ik moedig je aan om je werk te delen en ik hoop echt dat we van elkaar nieuwe trukjes kunnen leren en met Sonic Pi verder kunnen evolueren. Ik ben er echt enthousiast om wat jij mij gaat laten zien.

# - Optreden

Een van de meest boeiende aspecten van Sonic Pi is dat je code kunt gebruiken als een muzikaal instrument. Dit betekent dat het schrijven van live code kan worden gezien als een nieuwe manier om muziek uit te voeren.

We noemen dit Live coderen.

## Laat je scherm zien

Wanneer je live codeert rad ik je aan om je scherm te tonen aan je publiek. Anders ben je je als een gitarist die zijn handen niet laat zien. Wanneer ik thuis oefen gebruik ik een Raspberry Pi en een kleine mini projector gericht op de muur van mijn living. Je zou je TV kunnen gebruiken of een projector van het werk of jouw school om een show te geven. Probeer dit, het is erg leuk.

## Vorm een Band

Don’t just play on your own - form a live coding band! It’s a lot of fun jamming with others. One person could do beats, another ambient background, etc. Use the `live_audio` functionality to combine code with traditional instruments such as a guitar or a microphone.

See what interesting combinations of sounds you can create with code.

## TOPLAP

Live coderen is niet nieuw - een kleine groep mensen doen dit al gedurende enkele jaren meestal met behulp van op maat gemaakte systemen die ze voor zichzelf hebben gebouwd. Een goeie plek om meer over deze live coders en hun systemen te weten te komen is TOPLAP.

## Algorave

Een andere interessante bron om de wereld van live coding te leren kennen is Algorave. Hier kan je alles vinden over de verschillende onderdelen om live te spelen in een nachtclub.

# - Minecraft Pi

Sonic Pi ondersteunt nu een eenvoudige API voor interactie met Minecraft Pi - de speciale editie van Minecraft is standaard op de Raspberry Pi’s (Raspbian’s Linux-gebaseerd OS) geïnstalleerd.

## Libraries importeren onnodig

De Minecraft Pi-integratie is ontwikkeld om makkelijk te gebruiken. Al wat je moet te doen is te Minecraft Pi lanceren en een wereld creëren. Dan bent je vrij om `mc_*` fns te gebruiken, net zoals `play` and `synth` . Er is geen behoefte om te bibliotheken te gaan importeren -alles is klaar om te gaan gebruiken.

## Automatische Verbinding

De Minecraft Pi API zorgt voor het beheren van uw verbinding met de Minecraft Pi-toepassing.Geen zorgen dus. Als u probeert Minecraft Pi API te gebruiken wanneer Minecraft Pi niet geopend is, zal Sonic Pi je dat vriendelijk vertellen.Ook als u Minecraft Pi sluit terwij ler nog steeds een ‘live_loop’ speelt, die gebruik maakt van de API, zal de live loop stoppen en je vertellen dat deze geen verbinding kan maken. Als je wil verbinden, lanceer gewoon opnieuw de Minecraft Pi en Sonic Pi zal dan automatisch detecteren en de verbinding voor u opnieuw maken.

## Ontworpen om Live gecodeerd te worden

De Minecraft Pi API is ontworpen om naadloos te werken binnen ‘ live_loop. Hierdoor is het mogelijk om wijzigingen in uw Minecraft Pi werelden te synchroniseren met wijzigingen in uw Sonic Pi klanken. Instant Minecraft gebaseerde muziek video’s! Merk wel op dat het gaat om Minecraft Pi Alfa software is endus enigszins buggy. Als u problemen hebt, start Minecraft Pi gewoon terug op. Sonic Pi’s automatische verbinding functionaliteit zal voor de rest zorgen.

## Een Raspberry Pi 2.0 vereist

Het is sterk aanbevolen een Raspberry Pi 2 te gebruiken als u Sonic Pi en Minecraft samen gebruikt - vooral als je gebruik wilt maken van Sonic Pi’s geluids mogelijkheden.

## API-ondersteuning

In dit stadium ondersteunt Sonic Pi fundamentele blok en manipulaties van de speler die zijn beschreven in de sectie 11.1. Ondersteuning voor event callbacks getriggerd door interacties met de speler en de rest van de wereld is gepland voor een toekomstige versie.

# 11.1 - Basis Minecraft Pi API

Sonic Pi ondersteunt momenteel de volgende fundamentele interacties met Minecraft Pi:

Chatberichten weergeven De plaats van de gebruiker instellen De positie van de gebruiker verkrijgen Het bloktype instellen op een bepaalde coördinaat Het krijgen van het bloktype bij een bepaalde coördinaat

Laten we deze op hun beurt eens bekijken .

## Chatberichten weergeven

Laten we eens kijken hoe makkelijk het is om Minecraft Pi vanuit Sonic Pi te controllen. Controleer eerst of u zowel Minecraft Pi en Sonic Pi open hebt staan en ook zorg ervoor dat u een Minecraft wereld hebt ingevoerd en je hier kan in rondlopen.

Voer de volgende code in een verse Sonic Pi-buffer:

    mc_message "Hello from Sonic Pi"

Wanneer je de Afspeel knop indrukt zal je je berichtje openspringen op het Minecraft-scherm. Gefeliciteerd, hebt u uw eerste Minecraft code geschreven! Dat was niet moeilijk.

## De plaats van de gebruiker instellen

Nu gaan we wat magie gebruiken. Laten we onszelf naar ergens anders teleporteren. Probeer het volgende:

    mc_teleport 50, 50, 50

Wanneer je de * afspeel* knop indrukt - bam! Je bent inmiddelijk op een nieuwe plek. Waarschijnlijk ergens in de lucht en dat je op de grond of in het water viel. Nu, wat zijn die nummers : ‘50, 50, 50’? Dat zijn de coördinaten van de plaats waarnaartoe je probeerde te teleporteren. Neem de tijd om coördinaten te verkennen en wat deze zijn en hoe ze werken.Dit is echt belangrijk om Minecraft te kunnen programmeren.

## Coördinaten

Stel je een piraten kaart voor met een grote `X`om de locatie van één of andere schat te markeren. De exacte locatie van de `X` kan beschreven worden met twee cijfers- hoe ver van links naar rechts op de kaart en hoe ver op de kaart van beneden naar boven in de kaart. Bijvoorbeeld `10cm` over en `8cm` naar omhoog. Deze twee nummers `10`en `8` zijn coördinaten. Je kan je goed voorstellen hoe andere locaties van schatten met andere cijfercombinaties worden beschreven. Misschien is er een grote kist met goud aan `2` en `9` omhoog…

Nu, twee getallen zijn in Minecraft niet genoeg. We willen ook weten hoe hoog we zitten. Daarvoor hebben we drie getallen nodig:

Hoe ver van rechts naar links in de wereld - ‘x’ Hoe ver van voor naar achter in de wereld - ‘z’ Hoe hoog, we in de wereld zijn - ‘y’

Nog even dit - meestal schrijven we deze coördinaten in deze volgorde`x`, `y`, `z`.

## Je huidige coördinaten vinden

Laten we een spelletje doen met de coördinaten. Navigeer naar een mooie plek in de Minecraft kaart en schakel om naar Sonic Pi. Voer nu de volgende gegevens in:

    puts mc_location

Wanneer je op deAfspeel knop drukt zie je de coördinaten van uw huidige positie weergegeven worden in het logboekvenster. Neem hier nota van, ga vooruit in de wereld en probeer het dan nog eens. Merk op hoe de coördinaten veranderen! Nu, adviseer ik je om dit even te herhalen - beweeg een beetje in de wereld, neem een kijkje naar de coördinaten en herhaal opnieuw. Doe dit tot je er een zeker gevoel voor begint te krijgen, hoe deze coördinaten veranderen wanneer je je verplaatst. Zodra je hebt begrepen hoe deze coördinaten werken, zal het programmeren met de Minecraft-API peanuts worden.

## Laten we gaan bouwen!

Nu je de huidige positie weet te vinden en je kan teleporteren met behulp van coördinaten, heb je alle hulpmiddelen die die je nodig hebt om met code te gaan beginnen bouwen in Minecraft. Stel dat je het blok met coördinaten `40`, `50`, `60` van glas wordt. Dat is nu super eenvoudig:

    mc_set_block :glass, 40, 50, 60

Haha, het was echt zo makkelijk. Om je werkstuk te zien, teleporteer je je in de buurt en bekijk deze nu:

    mc_teleport 35, 50, 60

Draai nu even rond en je zou je glazen blok moeten zien staan! Probeer deze nu in diamant te veranderen:

    mc_set_block :diamond, 40, 50, 60

Als je goed keek, zag je het met jij eigen ogen veranderen! Dit is het begin van iets groots…

## Blokken bekijken

Nog een laatste, voor we ons in iets anders engageren. Met een set van coördinaten kunnen we Minecraft vragen, welk type een bepaalde blok is. Laat ons dit proberen met onze zopas aangemaakte blok:

    puts mc_get_block 40, 50, 60

Jeuj! Het is `:diamond`.Probeer deze nu terug te veranderen naar glas en vraag het dan opnieuw. Zegt het nu `:glass`? Ik ben zeker van wel :-)

## De beschikbare bloktypes

Voor je helemaal loos gaat met het coderen van Minecraft Pi, moet je misschien deze lijst met beschikbare bloktypes even bekijken:

        :air
        :stone
        :grass
        :dirt
        :cobblestone
        :wood_plank
        :sapling
        :bedrock
        :water_flowing
        :water
        :water_stationary
        :lava_flowing
        :lava
        :lava_stationary
        :sand
        :gravel
        :gold_ore
        :iron_ore
        :coal_ore
        :wood
        :leaves
        :glass
        :lapis
        :lapis_lazuli_block
        :sandstone
        :bed
        :cobweb
        :grass_tall
        :flower_yellow
        :flower_cyan
        :mushroom_brown
        :mushroom_red
        :gold_block
        :gold
        :iron_block
        :iron
        :stone_slab_double
        :stone_slab
        :brick
        :brick_block
        :tnt
        :bookshelf
        :moss_stone
        :obsidian
        :torch
        :fire
        :stairs_wood
        :chest
        :diamond_ore
        :diamond_block
        :diamond
        :crafting_table
        :farmland
        :furnace_inactive
        :furnace_active
        :door_wood
        :ladder
        :stairs_cobblestone
        :door_iron
        :redstone_ore
        :snow
        :ice
        :snow_block
        :cactus
        :clay
        :sugar_cane
        :fence
        :glowstone_block
        :bedrock_invisible
        :stone_brick
        :glass_pane
        :melon
        :fence_gate
        :glowing_obsidian
        :nether_reactor_core