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…
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.
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 …
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
endKlik 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
endSpeel 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
endMerk 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
endBlijf 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 . . .
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 I - Cue Viewer
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.
These orange buttons allow you to manipulate the code editor. The Size + and Size - buttons allow you to make the text bigger and smaller.
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.
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.
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.
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.
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.
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).
All internal and external events (called cues in Sonic Pi) are automatically logged in the Cue Viewer. For example, if you have a MIDI controller connected and press one of its buttons, you’ll see a new cue event in the Cue Viewer telling you the name of the controller and which button you pressed. Once you’ve mastered the basics of making and producing sounds, you’ll start to want to cue sounds or whole sections of sounds based on events such as these. A cue event is just an indication that something happened. For example, every time a live loop spins round, it sends a cue event out which is logged in the Cue Viewer. Also, external events such as MIDI messages from connected MIDI equipment and OSC messages from other programs or computers are also displayed in the Cue Viewer. It is also possible to directly generate cue events using the cue function. Anything that appears in the Cue Viewer can be used to trigger something happening. This is covered in more detail in Sections 10 to 12 of this tutorial.
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.
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.
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!
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…
Bestudeer de volgende code:
play 70Dit 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…
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 75Hoor je het verschil? Probeer een lager cijfer:
play 60So, 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.
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 79Jazzy! 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.
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 79Hoe 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 79Merk 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.
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 :EDenk 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 :E4Als 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.
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.
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.5De volgorde van de opts maakt niet uit, dus het volgende is identiek:
play 50, eieren: 0.5, kaas: 1Opts 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: 2Opts 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 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.
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.5Afspelen op dubbel zo hoge amplitude gebruik 2:
play 60, amp: 2De 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 65Natuurlijk 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: 1Een 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: -1En nu uit de rechter luidspreker:
play 60, pan: 1En nu terug vanuit beiden samen (standaard positie):
play 60, pan: 0Doe nu maar, en veel plezier met het veranderen van de amplitude en het pannen van uw geluiden!
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.
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.
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.25Laten 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.25Hoe 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.25Now 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.25Merk 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.
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.
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
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.
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.
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 70De noot zal 1 seconde lang hoorbaar zijn. Chronometreer maar :-) Dit is de verkorting van de langere, meer uitgesproken versie:
play 70, release: 1Merk 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: 2We kunnen de synth voor een heel korte tijd laten klinken door een heel korte release tijd te gebruiken:
play 60, release: 0.2De 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.
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.5Je kan meerdere opties tegelijk kiezen. Probeer deze bijvoorbeeld voor een kortere aanslag en een langere uitloop:
play 60, attack: 0.7, release: 4Deze 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
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.
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
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, deze door sample zullen genegeerd worden.
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.
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 .
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: 1Deze 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.5Woah! 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.
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_amenDoor de koerssnelheid te veranderen kunnen we van genre schakelen. Probeer eens halve snelheid voor old school hiphop:
sample :loop_amen, rate: 0.5Als we het versnellen, komen we op het grondgebied van jungle:
sample :loop_amen, rate: 1.5En nog een laatste truc - laten we eens kijken wat er gebeurt als we gebruik maken van een negatieve koers:
sample :loop_amen, rate: -1Woah! 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 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.
(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.
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.
Laten we terugkeren naar onze trouwe vriend de Amen Break:
sample :loop_amenZonder 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: 1Voor een kortere fade in, kies een kleinere waarde voor de attack:
sample :loop_amen, attack: 0.3Waar 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.
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_amenHet 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.75Het 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 .
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.75Als 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.
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.75Nu zal onze sample in totaal 0.75s spelen. Met de standaard waarden voor attack: endecay: 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.
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_openJe 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.1Je 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.1Leef je uit door aan samples een envelop toe te voegen. Probeer ook de rate te veranderen voor echt interessante resultaten.
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_amenVervolgens hebben we gekeken hoe we de rate kunnen wijzigen naar bv. het afspelen op halve snelheid:
sample :loop_amen, rate: 0.5Verder hebben we gekeken hoe we deze sample konden in fade-en (we doen deze op halve snelheid):
sample :loop_amen, rate: 0.5, attack: 1We 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.35Zou 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?
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.5Of het laatste kwart van de sample:
sample :loop_amen, start: 0.75Ook 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.5Natuurlijk 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.6Wat gebeurd er als we een startpunt achter het eind punt kiezen?
sample :loop_amen, start: 0.6, finish: 0.4Cool! Het speelt achterstevoren!
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.2Tot 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: 1Experimenteer er nu maar even op los en maak leuke mash-ups van samples met deze toffe nieuwigheden…
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.
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.
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.3Opmerking 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?
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/", 0We kunnen zelfs een binnenweg maken naar ons pad van de map met behulp van een variabele:
samps = "/pad/naar/mijn/samples/"
sample samps, 0Als 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, 1Merk 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.
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", 1We 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: 2Het 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, 0Hier 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, 0Hou 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.
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.5Zie hulp voor sample voor vele gedetailleerde gebruiksvoorbeelden. Merk op dat de volgorde van de filters geëerd wordt.
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#"]]]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.
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.
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!
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)
endEen 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
endDus, 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
endTelkens 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
endDit 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.
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
endWe 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
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
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
endVergelijkbaar met de relatie tussen ‘rrand_i’ en ‘rrand’, ‘rand_i’ geeft een willekeurig geheel getal tussen 0 en de max waarde die u opgeeft.
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!
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!
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…
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 62Om 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
endMaar… 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.
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.
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.25Wat 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.25Dat 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.
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 endop 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
endNu 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
endWe 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
endAls 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
endBelangrijk 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_openNu gaan we de code structureren met iteratie en loops!
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’.
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
endMerk 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
endDit keer hebben we verschillende rustijden afhankelijk van de keuze die wordt gemaakt.
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
endDit zal akoorden met andere getallen, bij iedere gespeelde noot, de kans op een verschillende mogelijkheid spelen.
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.
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
endZoals 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.
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
endDoor 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
endNu 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
endWat 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.
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 50Merk 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.
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
endMerk 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.
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
endKijk 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}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
endGa 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
endProbeer 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…
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.
define :foo do
play 50
sleep 1
play 55
sleep 2
endHier 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.
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
endWe 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.
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:
fooDruk 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).
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 90Dit 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 nnu 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 nis 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, 3Hier 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!
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_amenHier, 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_nameEr 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.
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.7533Waarom 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_durationHet 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 .
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_amens 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.
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: 8Nu 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: 62We zullen het manipuleren van synth’s in een later sectie meer in detail bekijken.
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 :sorted do
a = a.sort
sleep 0.5
puts "sorted: ", a
end
live_loop :shuffled do
a = a.shuffle
sleep 0.5
endIn 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
endSoms 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.
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.
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.
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
endHier 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
endDie 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.
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
endHier hebben we een hoofd cue loop die random de heartbeat namen :foo, :bar or :bazuitzend. 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 desync threads gewoon op de volgende cue zitten wachten.
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…
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!
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.
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
endSpeel 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 55Merk 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 55Er 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
endLaten 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
endLaat 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
endEen 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
endDenk 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.
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!
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
endIn 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
endWe 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
endOp 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
endIn 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.
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.
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: 5Hier 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: 72Wat 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.
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.
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
endIn 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 !
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: 72Hier 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: 72Nu horen we de de noten buigen tussen de controlaanroep. 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.
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.
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
endVeel plezier met het rond slide-en van zaken voor een vloeiende overgang en een vlotte control…
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.
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 59Laten we eens kijken naar andere manieren om deze code weer te geven.
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.3Natuurlijk 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.
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…
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)
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.25We 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 73Welke wil je liever schrijven?
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.1We kunnen zelfs meer octaven vragen:
play_pattern_timed scale(:c3, :major, num_octaves: 3), 0.125, release: 0.1Wat dacht je van deze noten in een pentatonische toonladder?
play_pattern_timed scale(:c3, :major_pentatonic, num_octaves: 3), 0.125, release: 0.1Akkoorden 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
endProbeer verschillende akkoordnamen en cutoff in te geven.
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.
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.
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].ringEens 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] #=> 59Laten 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.
Handig om weten is dat de lijsten door scale en de chord opgeroepen, ook ringen zijn en jou toelaten willekeurige indexen te openen.
Naast de ring zijn er een aantal andere functies die een ring voor ons zullen bouwen.
rangenodigt je uit om een start en een eindpositie op te geven en de grootte van de stappen.
bools laten het gebruik van 1s en 0s 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.
Als toevoeging tot de bouwers zoals rangeen spreadis het manipuleren van bestaande ringen, een andere manier om nieuwe ringen te maken.
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)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.
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.
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.
É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? …
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
endAls 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…
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
endNu 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
endWat 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
endOf 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
endTen 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
endNu 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…
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
endDruk 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
endSla 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
endSla 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
endVerander 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
endStop nu met naar mij te luisteren en ga zelf aan de slag! Veel plezier!
Beschouw even de volgende code:
live_loop :foo do
play 50
sleep 1
endJe 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
endJe kan nu elke live loop onafhankelijk van elkaar wijzigen en updaten en het werkt gewoon allemaal.
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
endLaten 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
endWe 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
endWow, nu is alles perfect in tijd - allemaal zonder te stoppen.
Ga nu door met je live code en live loops!
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.
Sonic Pi biedt een zeer handig hulpmiddel voor het werken met ringen binnen live_loops. 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
endDit is gelijk aan:
live_loop :arp do
play (scale :e3, :minor_pentatonic).tick, release: 0.1
sleep 0.125
endHier 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
endU 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
endHet 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.
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.
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)
endHier 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 :fooen een andere :bar. Als we naar dezen willen kijken ( look), moeten we ook de naam van de tick doorgeven aan look.
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_loops.
Neem een kijkje naar de documentatie ‘Tick’ waar nuttige voorbeelden te vinden zijn. Nog een leuke tick verder!
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…
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…
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, 3000We 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, 3000In 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.
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 3000Merk op dat aanroepen van get informatie kunnen teruggeven die was geset in de vorige uitvoering. Wanneer een stuk informatie is geset 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.
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
endHet 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.6048583984375Probeer 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).
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
endLaten 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]
endMerk 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.
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 *.
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, 1In 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.
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.5Let 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.
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.
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 /*/*/*/*/*
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
foo
cue "/bla/bar/baz"
cue "/bla/bar/beans/baz"
cue "/bla/baz"
cue "/bla/a/b/c/d/e/f/baz"
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"
foo
cue "/bla/bar/quux"
cue "/bla/beans/quux"
cue "/bla/eggs/quux"
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"
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_amenFor 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
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…
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!
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
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!
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.
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
endThere’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
endUpdate the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let’s get rid of that pesky pause.
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 syncing 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
endUpdate 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!
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…
choose
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_.
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.
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, 50This 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 :e3By 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: 3Of 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: 5Finally, 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).
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.
Tijd toestand
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
endIn 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.
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)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.
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.)
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!
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.
One simple (and perhaps familiar) way of accessing sound inputs is using our friend synth by specifying the :sound_in synth:
synth :sound_inThis 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.
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: 8Of 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
endIf 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
endYou 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
endHowever, 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.
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.
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 :blaThis 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.
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
endHowever, 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
endNow, 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
endfoo
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, :stopIt can easily be restarted by calling it without the :stop arg again:
live_audio :blaAdditionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).
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: 2Note 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.
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.
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
endThe 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.
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
endIn 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.
choose
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_amenIn 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.
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
Bijlage A verzamelt alle de Sonic Pi artikelen geschreven voor het tijdschrift MagPi.
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.
Je kan ze in hun glorieuze professioneel ✓ vorm zien in de gratis PDF-downloads van de MagPi : https://www.raspberrypi.org/magpi/
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!
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.
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
endAls 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
endAls 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
endDenk eraan , je kan elke code omhullen met with_fx en elke klank hierin gecreëerd zal door deze FX passeren.
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_em9Ooh, een mooie gitaarklank! Nu gaan we hiermee spelen. Wat dacht je van zijn koers te veranderen?
sample :guit_em9, rate: 0.5Hé, 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
endProbeer nu de feedback te verhogen naar 1 om maffe klanken te horen. Lees de documentatie voor details over de beschikbare opts.
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
endKlik 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_loops 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.
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
endWanneer 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
endNu, 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.
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.
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
endEr zitten 4 basisingrediënten in een live_loop. De eerst is de naam. Onze live_loopheet :beats. Je kan jouw live_loopbenoemen 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 endwoord dat het einde van onzelive_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!.
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
endKlik 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!
Een van de belangrijkste lessen over live_loops is dat ze rust nodig hebben. Beschouw deze volgende ‘live_loop’:
live_loop :infinite_impossibilities do
sample :ambi_choir
endWanneer 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.
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_loops!
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
endHier 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_loops 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
endIn 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
endEen 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!
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_amenKlik 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.
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
endOK, 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 van2tellen 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_stretchopt 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 sampleen 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.
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 sleephebben en dat onze BPM 30 is, maar alles is wel in maat. De beat_stretchopt werkt met de huidige BPM om ervoor te zorgen dat alles werkt.
Nu komt het leuke! Terwijl de loop nog altijd speelt, verander de30in de use_bpm 30regel 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!
Nu we samples kunnen live lopen, laat ons eens kijken naar de leukste opts die bij de samplesynth geleverd zijn. Eerst komt cutoffaan 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.
Nog een fantastisch hulpmiddel om mee aan de slag te gaan is de slicer FX. Deze zal het geluid uiteen hakken (snijden). Omhul de sampleregel 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
endMerk op hoe de klank op en neer stuitert, elke keer meer. (Je kan de originele klank, zonder FX, beluisteren door de mix opt naar 0te 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).
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
endOf 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!
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
endKijk 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 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.
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
endHier 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.
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
endEen 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!
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.
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
endEen 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.
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
endAls 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 :e1Acid Bass in een oogwenk! We gaan hier mee spelen…
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
endLaten 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 :e3zijn 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 130en 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).1is de pulsgolf (pulse wave) en 2is 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.
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
endVoor 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!
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
endHallo 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.
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!
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, 100Jeetje! 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!"
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, zKijk 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
endNu, 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.
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_loops :-) 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
endNu, 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 70naar 80en nog hoger tot 100. Leuk niet?
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
endNa 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.
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!
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.
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 enplay :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:
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.
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.
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
endFantastisch, 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!
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 :den 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
endProbeer nu de andere noten in de baslijn: :aen :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.75en 1.
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
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…
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…
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 + 8Wanneer 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!
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
endHoe 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?
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
endBehoorlijk 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!
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!
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 randEn 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.
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
endTyp 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.
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.
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
endGeweldig, 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
endInteressant, 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
endNu, terwijl deze nog speelt, verander je de seed waarde van 0naar 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.
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
endTot 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.
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: 100Druk 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!
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: 130Laten 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
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
endIn 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)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: 130Merk 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 …
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
endVorige 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.
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 #=> 0Dit 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 #=> 2Telkens 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 0zal uitprinten naar het log op het moment dat dit in het programma voorkomt.
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 #=> 1In 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 ticks gaven 0en 1 zoals verwacht weer. daarna gaven de twee looks de laatste waarde van de beat weer, die 1was.
Nu kunnen we dus de beat verhogen door middel van ticken 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 #=> 3Neem 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.
De sterke kant hiervan komt naar boven als je tick mixt met ring en live_loopss. 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
endLaten 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.
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
endEen 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
endHoewel 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.
Laat ons de opgestoken kennis over ticks, rings en live_loops 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
endEen 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 .
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_amenEen 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.
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: enfinish: 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 en1 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.5We kunnen ook een start: toevoegen om een nog kleiner stukje van de sample te kunnen spelen:
sample :loop_amen, start: 0.25, finish: 0.5Voor 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.25Nu 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
endWe 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 sen 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 sampleen 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.
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
endIn 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!
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
endKijk hoe in het logboek waarden tussen 1 en 6 wordt afgedrukt, alsof we een echte dobbelsteen geworpen zouden hebben.
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
endLaat 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_beatheet , 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 dicefunctie aan dewelke, zoals we reeds zagen, een waarde tussen 1 en 6 zal teruggeven.
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
endStart 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!
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
endOpnieuw, 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!
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
endWat 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.
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
endDeze 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.
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: 80Laat ons dit nu door het :slicerFX leiden:
with_fx :slicer do
synth :prophet, note: :e1, release: 8, cutoff: 70
synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
endHoor 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
endSpeel 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.
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
endSpeel 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 en1. Door te gaan spelen met de phase:, wave:, invert_wave: enphase_offset opties kan je de amplitude binnen een tijdsverloop dramatisch veranderen.
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
endDit is zoals je de volumeknop van je hi-fi op en neer zou bewegen, zodat het geluid een beetje aan en uit ‘wiebelt’.
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
endHoor 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 enshuffle. 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
endWat 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
endHiermee 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.
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
endLaten 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
endIn 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.
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 enr 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.
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: 90Klik 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: 90Klik nu terug op Afspelen, om beide klanken, tegelijk te horen spelen. Dit komt omdat de Afspelenknop 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: 1Probeer 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.
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_loopte 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_loops, 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_loopom 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.
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: 30Je kan dan snel terug naar boven schuiven voor een hogere waarde met:
set_mixer_control! lpf_slide: 1, lpf: 130Als u optreed is het nuttig om een lege buffer vrij te houden om zoals hier met de mixer te werken.
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”.
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.
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.
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.
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.
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.
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.
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!
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.
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 .
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.
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!
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!
Om de afspeelsnelheid van de sample te wijzigen moeten we de rate: optie gebruiken:
sample :guit_em9, rate: 1Als 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: van0.5:
sample :guit_em9, rate: 0.5Merk 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.
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: -1Nu versnellen we deze een beetje:
sample :loop_amen, rate: 1.5Ha! 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 100gebruikt, verandert de drumloop naar een enkele klik!
Ik weet zeker dat velen nu gaan denken… “wat als we nu eens een negatieve waarde gebruiken voor de rate:?” Goeie vraag! Als 1de normale snelheid is en ´2´dubbele snelheid en waarbij 0,5 de halve snelheid is, dan moet -1achterwaarts zijn! Laten we dit met een snare uitproberen. Laten we deze eerst op normale snelheid afspelen:
sample :elec_filt_snare, rate: 1Cool! Het speelt achterstevoren:
sample :elec_filt_snare, rate: -1Natuurlijk 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!
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.
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.5Maar, 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: 7Als 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: 1Laat 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
endDit 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.
Laten we beginnen met het meest elementaire geluid dat er is - de eenvoudige zuiver gestemde sinus golf:
synth :sine, note: :d3Laten we eens kijken hoe dit klinkt gecombineerd met een blokgolf:
synth :sine, note: :d3
synth :square, note: :d3Merk 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.
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.4Nu, 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.
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 + detuneAls 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.5en luister hoe het geluid hierbij veranderen kan. Merk op dat lage ontstemde noten zoals bij 0.1een 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’.
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: 90In 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 (90en 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.)
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!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.
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:sawgolf volstaan:
synth :saw, note: :e2, release: 4Merk 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 :beeptoon:
synth :beep, note: :e2, release: 4Vermits 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 :sawhoorde. Het is dit bezige, variërende geluid van de sinus golf, die we kunnen gaan gebruiken voor subtractieve synthese.
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
endAls je goed luistert zal je horen dat wat geroezemoes en knapperigheid verwijderd is. In feite zijn alle frequenties in het geluid boven 100gereduceerd 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
endMerk 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.
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.
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
endLaat ons even kijken naar wat hier gebeurt. Eerst starten we een :lpf FX blok met een initiële cutoff: zeer laag op20. 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.
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(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?
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
Jylda and Sam Aaron perform at the Thinking Digital Conference in the Sage Gateshead. Photo credit: TyneSight Photos.
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.
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.
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 70A melody can be constructed with one more command, sleep:
lay 72
sleep 0.5
play 75
sleep 0.5
play 79In 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_amenThis 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.5In 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_amenrand
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.
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.
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.
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.
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.
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.
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 metC-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`.
Voor het automatisch uitlijnen van jouw code druk M-m.
Om het help-systeem in te schakelen kan je M-i indrukken. Een nog veel nuttiger sneltoets om te kennen is C-idie 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.
Het volgende is een samenvatting van de belangrijkste sneltoetsen die beschikbaar zijn in Sonic Pi. Zie sectie 10.1 voor motivatie en achtergrond.
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-rbetekent 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.
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
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.
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.
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
C-h - Vorige teken verwijderen
C-d - Volgend teken verwijderen
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
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 .
[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.
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 deOpname 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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 .
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.
Nu gaan we wat magie gebruiken. Laten we onszelf naar ergens anders teleporteren. Probeer het volgende:
mc_teleport 50, 50, 50Wanneer 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.
Stel je een piraten kaart voor met een grote Xom 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 10en 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 volgordex, y, z.
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_locationWanneer 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.
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, 60Haha, het was echt zo makkelijk. Om je werkstuk te zien, teleporteer je je in de buurt en bekijk deze nu:
mc_teleport 35, 50, 60Draai 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, 60Als je goed keek, zag je het met jij eigen ogen veranderen! Dit is het begin van iets groots…
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, 60Jeuj! 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 :-)
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